package clases;

import interfaz.dlg_presupuesto_prototipo;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;

/**
 *
 * @author MK
 */
public class NivelesTable {

    private ClsMetodos metodos = new ClsMetodos();
    private JTable tblPresupuesto;
    private JTable tblPartidasBase;
    private String idpresupuesto = "";
    private int cantidad_niveles;
    public int columnItem_EnTabla = 1;
    private JTable tblcapitulosBase;
    private dlg_presupuesto_prototipo dlg_presupuesto_prototipo;
    private boolean lasPartidasMismoNivelQCapitulos = false;

    public NivelesTable(String codigoProyecto, JTable tblPresupuestoTable, JTable tblPartidasTable, JTable tblcapitulostable, dlg_presupuesto_prototipo dlg) {
        tblPresupuesto = tblPresupuestoTable;
        tblPartidasBase = tblPartidasTable;
        idpresupuesto = codigoProyecto;
        tblcapitulosBase = tblcapitulostable;
        dlg_presupuesto_prototipo = dlg;
        cantidad_niveles = dlg.cantidad_niveles;
    }
    //___________________________________________________________________________________ Soy una barra separadora :)

    /**
     * Este metodo permite recorrer todas las filas necesarias para poder
     * actualizar los items de la JTable de Presupuesto
     *
     * @param disminuirNivel para este parametro se aceptan los siguientes
     * valores: -->> disminuirNivel=0 -> Es el valor por defecto, RECOMENDADO.
     */
    public void actualizarItems(int disminuirNivel) {
        try {
            DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
            int fileSelect = tblPresupuesto.getSelectedRow();
            System.out.println("============================ ACTUALIZAR ITEMS =======================");
            System.out.println("fileSelect>" + fileSelect + "");
            if (fileSelect != -1 && fileSelect + 1 < modeloTabla.getRowCount()) {
//            System.out.println("    ACTUALIZAR ITEMS: fileSelect>"+fileSelect+"  _extraerItemPresupuesto(fileSelect, 1):" + _extraerItemPresupuesto(fileSelect, 1)+"  fileSelect:"+fileSelect);
//            txtNombreProyecto.setText(String.valueOf(fileSelect));
                int i = 1;
                String numero = "";
                String itemMK = _extraerItemPresupuesto(fileSelect, columnItem_EnTabla);
                String itemD = _extraerItemPresupuesto(fileSelect + i, columnItem_EnTabla);
//            String itemMK_tipo=_extraerItemPresupuesto(fileSelect, 7);
                int lengthMKini = itemMK.length() - 2;
                int lengthMKfin = itemMK.length();
//            System.out.println("itemMK>>" + itemMK + " itemD>>" + itemD);
//            System.out.println("--------------------WHILE ACTUALIZAR---------------------");
                while (itemD.length() >= itemMK.length()) {
//                System.out.println("->i:" + i + "   itemMK>>" + itemMK + " itemD>>" + itemD);
                    if (fileSelect + i >= modeloTabla.getRowCount()) {
//                    System.out.println("i:" + i + " fileSelect+i:" + String.valueOf(fileSelect + i) + " modeloTabla.getRowCount():" + String.valueOf(modeloTabla.getRowCount()));
//                    System.out.println("----------->>>>----Break");
                        break;
                    }
                    //Si los dos tienen la misma longitud
                    if (itemMK.length() == itemD.length()) {
//                    if (itemMK.equals(itemD)) {
                        int valor = Integer.parseInt(itemMK.substring(lengthMKini, lengthMKfin));
                        valor++;
                        if (String.valueOf(valor).length() == 1) {
                            numero = "0" + valor;
                        } else {
                            numero = String.valueOf(valor);
                        }
                        itemMK = itemMK.substring(0, itemMK.length() - 2) + numero;
//                    System.out.println("fileSelect+i:" + String.valueOf(fileSelect + i) + " i:" + i + ">>>itemMK:" + itemMK + " numero:" + numero);
                        _escribirItemPresupuesto(itemMK, fileSelect + i, columnItem_EnTabla);
//                    }
                    } else {//Si no tienen la misma longitud
                        numero = itemMK.substring(itemMK.length() - 2, itemMK.length());
                        if (disminuirNivel == 0) {//Para un caso normal
                            itemD = itemD.substring(0, lengthMKini) + numero + itemD.substring(lengthMKfin, itemD.length());
                        }
//                    System.out.println("<<<<itemD:" + itemD + " numero:" + numero);
                        _escribirItemPresupuesto(itemD, fileSelect + i, columnItem_EnTabla);
                    }
                    i++;
                    if (fileSelect + i < modeloTabla.getRowCount()) {
                        itemD = _extraerItemPresupuesto(fileSelect + i, columnItem_EnTabla);
                    }
                }//FIN DEL WHILE
            }
            //-------------
        } catch (Exception e) {
            e.printStackTrace();
            ClsException._exceptionWriteFile(e, "ActualizarItems-NivelesTable.java");
        }
    }
//___________________________________________________________________________________ Soy una barra separadora :)

    public void aumentarNivel() {
        try {
            int fila_seleccionada = tblPresupuesto.getSelectedRow();
            if (fila_seleccionada != -1) {//Verificamos que se aya seleccionado una fila
                if (fila_seleccionada != 0) {//No tiene que ser la primera fila
                    DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
                    String itemActual = _extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla).trim();
                    String itemActual_tipo = modeloTabla.getValueAt(fila_seleccionada, columnItem_EnTabla + 8).toString().trim();
                    String itemAnterior = _extraerItemPresupuesto(fila_seleccionada - 1, columnItem_EnTabla).trim();
                    String itemAnterior_tipo = modeloTabla.getValueAt(fila_seleccionada - 1, columnItem_EnTabla + 8).toString().trim();
                    System.out.println("======================AUMENTAR NIVEL========================");
                    System.out.println("---->filaSelect:" + fila_seleccionada + "  itemActual:" + itemActual + "  itemAnterior:" + itemAnterior);

                    if (itemActual_tipo.equals("1")) {
                        //SI LA FILA SELECCIONADA ES NODO PADRE============================================================
                        int fila_posicionNodoPadre = -1;
                        boolean continuar = true;
                        //Vemos si el itemAnterior, es un Nodo Padre o un Nodo Hijo
                        if (itemAnterior_tipo.equals("1")) {
                            //Si es Nodo Padre
                            //Tenemos la posibilidad de aumentar al itemActual el nivel y hacer que 
                            //sea hijo del item Anterior, pero antes tenemos que condicionarle por:
                            //que no pase del limite de niveles permitidos
                            //que si tiene Nodos Hijos (el itemActual), entonces estos hijos tambien tienen
                            //que ser afectados al aumentar el nivel y no deben de superar el limite 
                            //de los niveles
                            //BUSCAREMOS la posicion del Nodo Padre para actualizar los items, pero eso al final
//                        fila_posicionNodoPadre=encontrarPosicionNodoPadre_aPartirDeNodoHijo(fila_seleccionada-1, modeloTabla);
                            continuar = true;
//                        System.out.println("<<<fila_posicionNodoPadre:"+fila_posicionNodoPadre+" <<<"+_extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla));
//                        JOptionPane.showMessageDialog(null, "*90");
                        } else {
                            //Si itemAnterior_tipo es Nodo Padre
                            //Y el itemAnterior es Nodo Hijo, entonces este pertenece a un Nodo Padre,
                            if (lasPartidasMismoNivelQCapitulos == false) {
                                //Si las partidas no tiene que estar en el mismo nivel de un capitulo entonces
                                if (itemAnterior.length() == itemActual.length() + 3) {
                                    continuar = false;
                                    dlg_presupuesto_prototipo.habilitar_mensaje(true, "No se puede aumentar de nivel, porque el Titulo anterior contiene partidas...  id:E20");
                                } else {
                                    continuar = true;
                                }

                            } else {
                            }
//                            JOptionPane.showMessageDialog(null, "*91");
                        }//Fin de itemAnterior es Nodo Hijo

                        //SI es TRUE, se puede aumentar de nivel
                        if (continuar) {
                            fila_posicionNodoPadre = encontrarPosicionNodoPadre_aPartirDeNodoHijo(fila_seleccionada - 1, modeloTabla);
                            System.out.println("<<<fila_posicionNodoPadre:" + fila_posicionNodoPadre + " <<<" + _extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla));
                            //                    JOptionPane.showMessageDialog(null, "*92");
                            //----------------------------------------------
                            //buscaremos el ultimo nodo hijo que pertenesca al itemActual, para saber
                            //hasta donde se tiene que aumentar el nivel, teniendo encuenta que no 
                            //debe pasar de los niveles permitidos
                            int fila_posicionNodoHijoUltimo_itemActual = encontrarPosicionNodoHijo_ultimo_aPartirDeNodoPadre(fila_seleccionada, modeloTabla);
                            //de los niveles
                            int nivel = encontrarElMayorNivel_aPartirDeNodoPadre(fila_seleccionada, modeloTabla);
                            System.out.println(">>>nivel:" + nivel + " >>>fila_posicionNodoHijoUltimo_itemActual:" + fila_posicionNodoHijoUltimo_itemActual);
                            if (nivel != -1 && nivel + 1 <= cantidad_niveles) {
                                //                        JOptionPane.showMessageDialog(null, "*93");
                                //Como cumple la condicion, ahora si podemos aumentar de nivel
                                String item = "";
                                if (itemActual.length() + 3 == itemAnterior.length()) {
                                    item = itemAnterior.substring(0, itemAnterior.length() - 2);
                                } else {
                                    item = itemAnterior.substring(0, itemActual.length()) + ".";
                                }
                                int valor = Integer.parseInt(itemAnterior.substring(itemAnterior.length() - 2, itemAnterior.length()));
                                valor++;
                                System.out.println(">>>>item:" + item + " >>>valor:" + valor);
                                if (valor < 10) {
                                    item = item + "0" + valor;
                                } else {
                                    item = item + valor;
                                }
                                String itemReemplazar = item;
                                String itemHijo = "";
                                //Actualizamos el itemActual, al valor que le corresponde mmkmk                            
                                //                            itemActual=itemAnterior.substring(0, itemAnterior.length()-2)+valor;
                                System.out.println(">>>itemReemplazar:" + itemReemplazar + " >>>item:" + item);
                                //Si son iguales, quiere decir que no tiene nodos hijos
                                if (fila_posicionNodoHijoUltimo_itemActual == fila_seleccionada) {
                                    if (itemActual.length() == itemAnterior.length()) {
                                        _escribirItemPresupuesto(itemAnterior + ".01", fila_seleccionada, columnItem_EnTabla);//acc-
                                    } else if (itemActual.length() < itemAnterior.length()) {
                                        _escribirItemPresupuesto(item, fila_seleccionada, columnItem_EnTabla);//acc-
                                    }
                                    //                            JOptionPane.showMessageDialog(null, "*97");
                                } else {
                                    //Quiere decir que si tiene nodos hijos
                                    if (itemActual.length() == itemAnterior.length()) {
                                        _escribirItemPresupuesto(itemAnterior + ".01", fila_seleccionada, columnItem_EnTabla);//acc-
                                        itemReemplazar = itemAnterior + ".01";
                                    } else if (itemActual.length() < itemAnterior.length()) {
                                        //                                JOptionPane.showMessageDialog(null, "*110");
                                        _escribirItemPresupuesto(item, fila_seleccionada, columnItem_EnTabla);//acc-
                                    }
                                    //                            JOptionPane.showMessageDialog(null, "*98");
                                    for (int i = fila_seleccionada + 1; i <= fila_posicionNodoHijoUltimo_itemActual; i++) {
                                        itemHijo = _extraerItemPresupuesto(i, columnItem_EnTabla);
                                        itemHijo = itemReemplazar + "." + itemHijo.substring(itemHijo.length() - 2, itemHijo.length());
                                        _escribirItemPresupuesto(itemHijo, i, columnItem_EnTabla);//acc-
                                    }
                                    //Actualizamos los items
                                }
                                int fila = encontrarPosicionNodoPadre_aPartirDeNodoHijo(fila_seleccionada - 1, modeloTabla);
                                if (fila != -1) {
                                    tblPresupuesto.changeSelection(fila, 1, false, false);
                                    actualizarItems(0);
                                } else {
                                }
                                tblPresupuesto.changeSelection(fila_seleccionada - 1, 1, false, false);
                                actualizarItems(0);//acc-
                                //-----
                                fila = encontrarPosicionNodoPadre_aPartirDeNodoHijo(fila_seleccionada, modeloTabla);
                                if (fila != -1) {
                                    tblPresupuesto.changeSelection(fila, 1, false, false);
                                    actualizarItems(0);
                                } else {
                                }
                                tblPresupuesto.changeSelection(fila_seleccionada, 1, false, false);
                                actualizarItems(0);//acc-
                            } else {//No se cumplio de la cantidad de niveles
                                //Si no se cumplio es por que supera la cantidad de niveles permitidos
                                //mostramos un mensaje
                                dlg_presupuesto_prototipo.habilitar_mensaje(true, "No se puede aumentar de nivel, porque esta definido de: " + (cantidad_niveles - 1) + " niveles para capítulos y " + (cantidad_niveles) + " niveles para partidas...  id:E14");
                                //                        JOptionPane.showMessageDialog(null, "*94");
                            }//FIn de verificacion de cantidad de niveles

                            //ACTUALIZAMOS LOS ITEMS
                            //SI se encontro la posicion del nodo padre, entonces
                            if (fila_posicionNodoPadre != -1) {
                                //Actualizamos los nodos respecto al Nodo Padre
                                tblPresupuesto.changeSelection(fila_posicionNodoPadre, 1, false, false);
                                //                        JOptionPane.showMessageDialog(null, "*95");
                                actualizarItems(0);//acc-
                            } else {
                            }

                            //SELECCIONAMOS a la fila movida
                            tblPresupuesto.changeSelection(fila_seleccionada, 1, false, false);
                            //                    JOptionPane.showMessageDialog(null, "*96");
                        } else {//SI EL continuar=false ENTONCES EL TITULO SELECCIONADO NO DEBERIA DE
                            //AUMENTAR DE NIVEL PORQUE EL ITEM ANTERIOR ES PARTIDA, ESTO ES DEBIDO A 
                            //QUE LAS PARTIDAS NO DEBEN DE ESTAR AL MISMO NIVEL DE LOS TITULOS
                            metodos.sonidoBeep();
                        }

                    } else {
                        //SI LA FILA SELECCIONADA ES NODO HIJO=================================================================

                        //Como es un Nodo Hijo, entonces se buscara hacia la parte superior un Nodo Padre del 
                        //mismo nivel, para poder agregarle al final de este Nodo Padre, pero si no se encuentra
                        //este Nodo Padre en la parte superior, entonces buscamos en la parte inferior, y si lo encontramos
                        //lo agregamos como nodo hijo...
                        //Teniendo encuenta tambien que no debe de pasar del limite de los niveles permitidos al usuario

                        if (!lasPartidasMismoNivelQCapitulos) {
                            //Si las partidas no tiene que estar en el mismo nivel de un capitulo entonces
                        } else {
                        }
                    }
                    //******
                }
            }
            //-------------
        } catch (Exception e) {
            ClsException._exceptionWriteFile(e, "AumentarNivel-NivelesTable.java");
            e.printStackTrace();
        }
    }

    public void disminuirNivel() {
        try {
            System.out.println("====================DisminuirNivel=======================");
            int fila_seleccionada = tblPresupuesto.getSelectedRow();
            if (fila_seleccionada != -1) {
                //Almacenamos el item de la fila seleccionada
                String items = _extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla).trim();
                //        JOptionPane.showMessageDialog(null, "*56 items:"+items+"   fila_seleccionada:"+fila_seleccionada);
                //Se tiene que seleccionar una fila de la tabla, y este ITEM tiene que ser mayor que 2, osea
                //no se aceptan items como: "02", "03", etc.. pues ya no se puede disminuir de nivel
                if (items.length() > 2) {
                    DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
                    //En esta variable "itemDisminuido" se almacenara el valor disminuido, ejmemplo:
                    //02.03 [NodoPadre]                     02.03 [NodoPadre]
                    //  02.03.01                              02.03.01
                    //  02.03.02                              02.03.02
                    //  02.03.03 [NodoPadre]                02.04 [NodoPadre] --> itemDisminuido
                    //      02.03.03.01                         02.04.01
                    //      02.03.03.02                         02.04.02
                    String itemDisminuido = items.substring(0, items.length() - 5);
                    int valor = Integer.parseInt(items.substring(items.length() - 5, items.length() - 3));
                    valor++;
                    if (String.valueOf(valor).length() == 1) {
                        itemDisminuido = itemDisminuido + "0" + valor;
                    } else {
                        itemDisminuido = itemDisminuido + "" + valor;
                    }
                    System.out.println("itemDisminuido:" + itemDisminuido + "   fila_seleccionada:" + fila_seleccionada);
                    //VERIFICAMOS SI ES NODO PADRE, el item seleccionado
                    if (modeloTabla.getValueAt(fila_seleccionada, columnItem_EnTabla + 8).toString().equals("1")) {
                        //Si es Padre ======================================================================================
                        System.out.println("ES NODO PADRE");
                        String itemComparar = _extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla);
                        //Actualizamos a la fiall seleccionada, el valor disminuido
                        _escribirItemPresupuesto(itemDisminuido, fila_seleccionada, columnItem_EnTabla);//item
                        //Actualizamos el nivel
                        int nivel = (itemDisminuido.length() + 1) / 3;//nivel
                        _escribirItemPresupuesto(nivel, fila_seleccionada, columnItem_EnTabla + 7);//nivel
                        if (itemDisminuido.length() == 2) {
                            _escribirItemPresupuesto("0", fila_seleccionada, columnItem_EnTabla + 6);//padre
                        } else {
                            _escribirItemPresupuesto(itemDisminuido.substring(0, itemDisminuido.length() - 3), fila_seleccionada, columnItem_EnTabla + 6);//padre
                        }
                        System.out.println("fila_seleccionada:" + fila_seleccionada);
//                    JOptionPane.showMessageDialog(null, "*57 itemComparar:"+itemComparar);
                        //Validamos que exista una fila mas a la seleccionada
                        if (fila_seleccionada + 1 < modeloTabla.getRowCount()) {
                            //entonces existe una fila mas, obtenemos el valor del item de este
                            String itemHijo = _extraerItemPresupuesto(fila_seleccionada + 1, columnItem_EnTabla);
                            int iFila_nodos_hijos = fila_seleccionada;
                            int fila_nodo_hijos_itemDisminuido = iFila_nodos_hijos;
                            if (itemComparar.length() < itemHijo.length()) {
                                iFila_nodos_hijos++;
                                //Aseguramos q el itemHijo pertenesca al Nodo Padre
                                //Recorremos los Nodos Hijos
                                //Comparamos el itemComparar y itemHijo
                                do {
                                    _escribirItemPresupuesto(itemDisminuido + itemHijo.substring(itemHijo.length() - 3, itemHijo.length()), iFila_nodos_hijos, columnItem_EnTabla);
//                                JOptionPane.showMessageDialog(null, "*57 itemHijo:"+itemHijo);
                                    iFila_nodos_hijos++;
                                    if (iFila_nodos_hijos >= modeloTabla.getRowCount()) {
                                        break;
                                    }
                                    itemHijo = _extraerItemPresupuesto(iFila_nodos_hijos, columnItem_EnTabla);
                                    System.out.println("iFila_nodos_hijos=" + iFila_nodos_hijos + "   itemComparar.length():" + itemComparar.length() + "    itemHijo.length():" + itemHijo.length());
                                } while (itemComparar.length() < itemHijo.length());
                                System.out.println("............iFila_nodos_hijos=" + iFila_nodos_hijos + "   itemComparar:" + itemComparar + "    itemHijo:" + itemHijo + "    itemDisminuido:" + itemDisminuido);
                                fila_nodo_hijos_itemDisminuido = iFila_nodos_hijos - 1;
                            } else {
                                //
//                            JOptionPane.showMessageDialog(null, "*58 itemHijo:"+itemHijo);
                                //SI los dos items son del mismo nivel
                                //entonces, buscamos el ultimo de ese nivel
                                //porq se agrega
                                if (itemComparar.length() == itemHijo.length()) {
//                                JOptionPane.showMessageDialog(null, "*8 itemComparar.length()==itemHijo.length()");
//                                if (modeloTabla.getValueAt(fila_seleccionada-1, columnItem_EnTabla+8).toString().equals("1")) {
//
//                                } else {
//                                }
                                    iFila_nodos_hijos++;
                                } else if (itemComparar.length() - 3 == itemHijo.length()) {
                                    //Si el itemHijo que es fila seleccionada +1, es
                                    //un nivel menos entonces ya no continua
//                                JOptionPane.showMessageDialog(null, "*2 itemComparar.length()-3==itemHijo.length()");
                                    iFila_nodos_hijos++;
                                }
                            }
                            System.out.println("=================================fila_nodo_hijos_itemDisminuido:" + fila_nodo_hijos_itemDisminuido + "  " + _extraerItemPresupuesto(fila_nodo_hijos_itemDisminuido, columnItem_EnTabla) + " Es el valor por el cual se reeemplazara...");

                            //****************************
                            //Buscamos nodos con igual niveles del itemComparar, que es la copia de lo q fue
                            //originalmente fila seleccionada
//                        if (iFila_nodos_hijos+1<modeloTabla.getRowCount()) {
                            if (iFila_nodos_hijos < modeloTabla.getRowCount()) {
                                System.out.println("=================================iFila_nodos_hijos:" + iFila_nodos_hijos + "  " + _extraerItemPresupuesto(iFila_nodos_hijos, columnItem_EnTabla));
                                String itemNodosDelMismoNivel = _extraerItemPresupuesto(iFila_nodos_hijos, columnItem_EnTabla);
//                            JOptionPane.showMessageDialog(null, "*65");
                                while (itemComparar.length() <= itemNodosDelMismoNivel.length()) {
                                    if (iFila_nodos_hijos + 1 >= modeloTabla.getRowCount()) {
                                        break;
                                    }
                                    iFila_nodos_hijos++;
//                                tblPresupuesto.changeSelection(iFila_nodos_hijos, 1, false, false);
//                                JOptionPane.showMessageDialog(null, "*64");
                                    itemNodosDelMismoNivel = _extraerItemPresupuesto(iFila_nodos_hijos, columnItem_EnTabla);
                                }
                                System.out.println(">iFila_nodos_hijos:" + iFila_nodos_hijos + "    _extraerItemPresupuesto(iFila_nodos_hijos, 1).toString():" + _extraerItemPresupuesto(iFila_nodos_hijos, columnItem_EnTabla));
                                tblPresupuesto.changeSelection(iFila_nodos_hijos, 1, false, false);
                                //                            modeloTabla.insertRow(iFila_nodos_hijos, new Object[modeloTabla.getRowCount()]);
//                                JOptionPane.showMessageDialog(null, "*3 Se inserto");
                                // (15/06/2013) para controlar cuando iFila_nodos_hijos es el ultimo
                                if (iFila_nodos_hijos + 1 >= modeloTabla.getRowCount()) {
                                    iFila_nodos_hijos++;
                                }
                            } else {
                                //SI el iFila_nodos_hijos es mayor que la cantidad de items que tiene la tabla, entonces
                                //estamos hablando de la ultima fila de la tabla, entonces insertamos
//                            modeloTabla.insertRow(iFila_nodos_hijos, new Object[modeloTabla.getRowCount()]);
//                            JOptionPane.showMessageDialog(null, "*71 Se inserto");
                            }
//                        tblPresupuesto.changeSelection(iFila_nodos_hijos, 1, false, false);
                            modeloTabla.insertRow(iFila_nodos_hijos, new Object[modeloTabla.getRowCount()]);
                            //JOptionPane.showMessageDialog(null, "*70 Se inserto");
                            //****************************
                            System.out.println("mkmk---->>>fila_seleccionada+iFila_nodos_hijos-fila_nodo_hijos_itemDisminuido:" + (fila_seleccionada + iFila_nodos_hijos - fila_nodo_hijos_itemDisminuido));
                            System.out.println("=====>>>fila_seleccionada:" + fila_seleccionada + "  " + _extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla));
                            System.out.println("=====>>>fila_nodo_hijos_itemDisminuido:" + fila_nodo_hijos_itemDisminuido + " >> " + _extraerItemPresupuesto(fila_nodo_hijos_itemDisminuido, columnItem_EnTabla));
//                        System.out.println("=====>>>(fila_seleccionada+iFila_nodos_hijos-fila_nodo_hijos_itemDisminuido):"+(fila_seleccionada+iFila_nodos_hijos-fila_nodo_hijos_itemDisminuido)+" <>> "+_extraerItemPresupuesto(fila_seleccionada+iFila_nodos_hijos-fila_nodo_hijos_itemDisminuido, columnItem_EnTabla));
//                            JOptionPane.showMessageDialog(null, "*63 movemos la fila");
                            modeloTabla.moveRow(fila_seleccionada, fila_nodo_hijos_itemDisminuido, fila_seleccionada + iFila_nodos_hijos - fila_nodo_hijos_itemDisminuido);

//                        tblPresupuesto.changeSelection(fila_seleccionada-1, 1, false, false);
                            tblPresupuesto.changeSelection(fila_seleccionada + iFila_nodos_hijos - fila_nodo_hijos_itemDisminuido - 1, 1, false, false);
//                        _escribirItemPresupuesto(itemDisminuido, fila_seleccionada, columnItem_EnTabla);
//                        JOptionPane.showMessageDialog(null, "*62 vamos a remover la fila insertada anteriormente");
                            modeloTabla.removeRow(fila_seleccionada + iFila_nodos_hijos - fila_nodo_hijos_itemDisminuido - 1);
//                            JOptionPane.showMessageDialog(null, "*67 Actualizamos los items");
                            actualizarItems(0);
                            tblPresupuesto.changeSelection(fila_seleccionada + iFila_nodos_hijos - fila_nodo_hijos_itemDisminuido - 1, 1, false, false);
                            //JOptionPane.showMessageDialog(null, "*68 BUCLES PARA ACTUALIZAR LOS ITEMS");

                            //++++++++++++++++++++++++++++++++++++++
                            //PARA ACTUALIZAR LOS ITEMS
                            //Buscamos en la parte superior, un item del mismo nivel del item seleccionado
                            if (fila_seleccionada - 1 >= 0) {
                                int fila = fila_seleccionada - 1;
                                itemHijo = _extraerItemPresupuesto(fila_seleccionada - 1, columnItem_EnTabla);
                                if (modeloTabla.getValueAt(fila, columnItem_EnTabla + 8).toString().equals("1") && itemHijo.length() == itemComparar.length() - 3) {
                                    System.out.println("++++++++++++++++++++itemDisminuido:" + itemDisminuido + "  item delaFilaSeleccionada:" + _extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla));
//                                JOptionPane.showMessageDialog(null, "*66 itemDisminuido "+itemDisminuido);
                                    //El itemDisminuido (osea si tenia: 02.02 ---> ahora disminuye a: 02, tiene que ser
                                    //diferente al obtenido por la fila_seleccionada, por que si es igual se le agregaria el .01
                                    //y con esto no se habria disminuido el item para nada...
                                    //pero si son diferentes entonces al mover el item afectado, en la fila: fila_seleccionada
                                    //garantizamos que no se trata del mismo item, y a este se le agrega el .01
                                    if (!itemDisminuido.equals(_extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla))) {
                                        itemComparar = itemHijo + ".01";
                                        _escribirItemPresupuesto(itemComparar, fila + 1, columnItem_EnTabla);
                                    }
                                } else {
                                    while (itemComparar.length() < itemHijo.length()) {
                                        if (modeloTabla.getValueAt(fila, columnItem_EnTabla + 8).toString().equals("1") && itemHijo.length() == itemComparar.length() - 3) {
                                            itemComparar = itemHijo + ".01";
                                            _escribirItemPresupuesto(itemComparar, fila + 1, columnItem_EnTabla);
                                            break;
                                        } else {
                                            if (fila - 1 < 0) {
                                                break;
                                            }
                                            fila--;
                                            itemHijo = _extraerItemPresupuesto(fila, columnItem_EnTabla);
                                        }
                                    }
                                }
                                tblPresupuesto.changeSelection(fila + 1, 1, false, false);
//                            JOptionPane.showMessageDialog(null, "*9 FILA");
                                actualizarItems(0);
                                tblPresupuesto.changeSelection(fila, 1, false, false);
                                actualizarItems(0);
                                //colocamos el focus, a la fila movida, para hacerle entender al usuario q se movio el item
                                tblPresupuesto.changeSelection(fila_seleccionada + iFila_nodos_hijos - fila_nodo_hijos_itemDisminuido - 1, 1, false, false);
                                actualizarItems(0);
                                //++++++++++++++++++++++++++++++++++++++
                            } else {
                            }
                        }
                    } else {//SI ES NODO HIJO ===================================================================================
                        System.out.println("ES NODO HIJO");
                        int i = 0;
                        //Verificamos que exista una fila mas a la seleccionada
                        if (fila_seleccionada + 1 < modeloTabla.getRowCount()) {
                            //Verificamos si es el primer nodo hijo con .01 y para verificar
                            //tenemos que confirmar una fila anterior que el tipo sea 1
                            //Osea tiene que ser Nodo Padre...
                            if (modeloTabla.getValueAt(fila_seleccionada - 1, columnItem_EnTabla + 8).toString().equals("1")) {
                                String itemCopia = _extraerItemPresupuesto(fila_seleccionada + 1, columnItem_EnTabla);
                                _escribirItemPresupuesto(itemCopia.substring(0, itemCopia.length() - 2) + "01", fila_seleccionada + 1, columnItem_EnTabla);
                            }
                            i = fila_seleccionada + 1;
                            String itemIterativo = _extraerItemPresupuesto(i, columnItem_EnTabla);
                            System.out.println(">>-->>i:" + i + "  itemIterativo: " + itemIterativo + "  itemDisminuido:" + itemDisminuido);
                            while (itemIterativo.length() != (itemDisminuido.length())) {
                                itemIterativo = _extraerItemPresupuesto(i, columnItem_EnTabla);
                                System.out.println("i:" + i + "  itemIterativo: " + itemIterativo + "  itemIterativo.length():" + itemIterativo.length() + "  (itemDisminuido.length()):" + (itemDisminuido.length()));
                                i++;
                                if (i >= modeloTabla.getRowCount()) {
                                    break;
                                }
                            }
                            //Si el "i" no se ejecuto dentro del WHILE, entonces en esa fila seleccionada se
                            //tendra que disminuir el Nivel, por eso y para compensar el valor de "i-2", se
                            //tiene que sumar +1, como si se hubiera ejecutado solo una vez en el while
                            if (i == fila_seleccionada + 1) {
                                i = i + 1;
                            }
                            //                    JOptionPane.showMessageDialog(null, "*10 fila_seleccionada:"+fila_seleccionada+"   i-2:"+(i-2));
                            modeloTabla.moveRow(fila_seleccionada, fila_seleccionada, i - 2);
                            //                JOptionPane.showMessageDialog(null, "*11 moveRow hecho-> fila_seleccionada:"+fila_seleccionada+"   i-2:"+(i-2));
                            _escribirItemPresupuesto(itemDisminuido, i - 2, columnItem_EnTabla);
                            //                JOptionPane.showMessageDialog(null, "*12 setValueAt hecho-> fila_seleccionada:"+fila_seleccionada+"   i-2:"+(i-2));
                            if (modeloTabla.getValueAt(fila_seleccionada - 1, columnItem_EnTabla + 8).toString().equals("1")) {
                                //                        tblPresupuesto.getSelectionModel().setSelectionInterval(fila_seleccionada, fila_seleccionada);
                                tblPresupuesto.changeSelection(fila_seleccionada, 1, false, false);
                            } else {
                                //                        tblPresupuesto.getSelectionModel().setSelectionInterval(fila_seleccionada-1, fila_seleccionada-1);
                                tblPresupuesto.changeSelection(fila_seleccionada - 1, 1, false, false);
                            }
                            //                    JOptionPane.showMessageDialog(null, "*13 -> fila_seleccionada:"+fila_seleccionada+"");
                            actualizarItems(0);
                            //                    tblPresupuesto.getSelectionModel().setSelectionInterval(i-2, i-2);
                            tblPresupuesto.changeSelection(i - 2, 1, false, false);
                            //                    JOptionPane.showMessageDialog(null, "*14 -> fila_seleccionada:"+fila_seleccionada+"   i-2:"+(i-2));
                            actualizarItems(0);
                        } else {//Si la fila seleccionada es la ultima de la tabla
                            System.out.println("Si la fila seleccionada es la ultima de la tabla...");
                            i = fila_seleccionada;
                            System.out.println("i:" + i + "  fila_seleccionada:" + fila_seleccionada);
                            //                    if (modeloTabla.getValueAt(fila_seleccionada-1, columnItem_EnTabla+8).toString().equals("1")) {
                            //                        tblPresupuesto.getSelectionModel().setSelectionInterval(fila_seleccionada, fila_seleccionada);
                            tblPresupuesto.changeSelection(fila_seleccionada, 1, false, false);
                            //                    } else {
                            //                        tblPresupuesto.getSelectionModel().setSelectionInterval(fila_seleccionada-1, fila_seleccionada-1);
                            //                    }
                            String itemSelect = _extraerItemPresupuesto(fila_seleccionada, columnItem_EnTabla);
                            String itemAnterior = _extraerItemPresupuesto(fila_seleccionada - 1, columnItem_EnTabla);
                            //Si los 2 tienen la misma longitud entonces
                            if (itemAnterior.length() > 2) {
                                valor = Integer.parseInt(itemAnterior.substring(itemAnterior.length() - 5, itemAnterior.length() - 3));
                                valor++;
                                itemSelect = itemSelect.substring(0, itemSelect.length() - 5);
                                if (String.valueOf(valor).length() == 1) {
                                    itemSelect = itemSelect + "0" + valor;
                                } else {
                                    itemSelect = itemSelect + "" + valor;
                                }
                                System.out.println("12 itemSelect:" + itemSelect);
                                //                        itemSelect=itemSelect.substring(0, itemSelect.length()-3);
                                _escribirItemPresupuesto(itemSelect, fila_seleccionada, columnItem_EnTabla);
                            }
                        }
                    }
                }
            } else {
                metodos.sonidoBeep();
            }
            //-------------
        } catch (Exception e) {
            e.printStackTrace();
            ClsException._exceptionWriteFile(e, "DisminuirNivel-NivelesTable.java");
        }
    }
    //___________________________________________________________________________________ Soy una barra separadora :)

    public void eliminar_fila(int fila, DefaultTableModel modeloTabla) {
        dlg_presupuesto_prototipo.elimina_item(fila);
        modeloTabla.removeRow(fila);
    }

    public void quitarNivel() {
        try {
            System.out.println("====================== QUITAR =============================");
            int fila_seleccion = tblPresupuesto.getSelectedRow();
            System.out.println("fila_seleccion:" + fila_seleccion);
            if (fila_seleccion != -1) {
                DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
                //Si el item seleccionado es NODO PADRE =======================================================================
                if (modeloTabla.getValueAt(fila_seleccion, columnItem_EnTabla + 8).toString().equals("1")) {
                    System.out.println("ES NODO PADRE");
                    String itemPadre = _extraerItemPresupuesto(fila_seleccion, columnItem_EnTabla);
                    String itemIterativo = "";
                    System.out.println("itemPadre:" + itemPadre);
                    //Garantizamos que la siguiente fila exista
                    if (fila_seleccion + 1 < modeloTabla.getRowCount()) {
                        itemIterativo = _extraerItemPresupuesto(fila_seleccion + 1, columnItem_EnTabla);
                        System.out.println("itemIterativo:" + itemIterativo);
                        //Buscamos los nodos Hijos para eliminarlos
                        while (itemPadre.length() < itemIterativo.length()) {
                            System.out.println("itemPadre:" + itemPadre + "  fila_seleccion+1:" + (fila_seleccion + 1) + "   itemIterativo:" + itemIterativo);
                            tblPresupuesto.changeSelection(fila_seleccion + 1, 1, false, false);
//                        JOptionPane.showMessageDialog(null, "*87");
                            eliminar_fila(fila_seleccion + 1, modeloTabla);
                            if (fila_seleccion + 1 < modeloTabla.getRowCount()) {
                                itemIterativo = _extraerItemPresupuesto(fila_seleccion + 1, columnItem_EnTabla);
                            } else {
                                System.out.println("---------->break");
                                break;
                            }
                        }
                        eliminar_fila(fila_seleccion, modeloTabla);//eliminamos 
//                    System.out.println("   ..,,fila_seleccion:"+fila_seleccion+"   _extraerItemPresupuesto(fila_seleccion, columnItem_EnTabla):"+(_extraerItemPresupuesto(fila_seleccion + 1, columnItem_EnTabla)));
//                    JOptionPane.showMessageDialog(null, "*15 fila_seleccion:"+fila_seleccion);
                        //Actualizamos los items
                        //
                        if (modeloTabla.getRowCount() > 0) {
                            int fila_actualizar = fila_seleccion;
                            //Si la fila que ahora toma la seleccion, es cero, entonces...
                            if (fila_seleccion == 0) {
                                //Colocamos el valor de 01, por ser la primera fila
                                _escribirItemPresupuesto("01", fila_seleccion, columnItem_EnTabla);
                                tblPresupuesto.changeSelection(fila_seleccion, 1, false, false);
                                actualizarItems(0);
                            } else if (fila_seleccion < modeloTabla.getRowCount()) {
                                //Si no es la primera fila entonces
                                if (modeloTabla.getValueAt(fila_seleccion - 1, columnItem_EnTabla + 8).toString().equals("0")) {
                                    fila_actualizar = encontrarPosicionNodoPadre_aPartirDeNodoHijo(fila_seleccion - 1, modeloTabla);
                                    if (fila_actualizar != -1) {
                                        tblPresupuesto.changeSelection(fila_actualizar, 1, false, false);
                                    }
                                } else {
                                    tblPresupuesto.changeSelection(fila_actualizar, 1, false, false);
                                }
                            } else {
                                tblPresupuesto.changeSelection(fila_seleccion - 1, 1, false, false);
                            }
                            actualizarItems(0);
                            tblPresupuesto.changeSelection(fila_seleccion - 1, 1, false, false);
                        } else {
                        }
                    } else {//Si la fila seleccionada es la ultima fila en el modelo o es la primera
                        eliminar_fila(fila_seleccion, modeloTabla);
                        tblPresupuesto.changeSelection(fila_seleccion - 1, 1, false, false);
                    }
                } else {//Si el item seleccionado es NODO HIJO=================================================================
                    System.out.println("ES NODO HIJO");
                    //Removemos el item seleccionado
                    eliminar_fila(fila_seleccion, modeloTabla);
                    //Verificamos que exista la fila_seleccionada
                    if (fila_seleccion < modeloTabla.getRowCount()) {
                        //Verificamos si la fila seleccionada es la primera fila
                        if (fila_seleccion == 0) {
                            //SI hay una fila mas, la 2da fila
                            if (modeloTabla.getRowCount() > 0) {
                                _escribirItemPresupuesto("01", 0, columnItem_EnTabla);
                                tblPresupuesto.changeSelection(0, 1, false, false);
                            }
                        } else {//Si no es la primera fila, puede ser cualquier otra fila
                            //Verificamos que exista la fila anterior
                            if (fila_seleccion > 0) {
                                //Verificamos que el itemAnterior sea un Nodo Padre
                                //Para asignarle por defecto el ".01", pero que
                                if (modeloTabla.getValueAt(fila_seleccion - 1, columnItem_EnTabla + 8).toString().equals("1")) {
//                                JOptionPane.showMessageDialog(null, "*17 mik23323e-1");
                                    //Si la fila_seleccion es la ultima, entonces no debe de existir esa ubicacion en la tabla
                                    //FALTA COMPROBAR LAS POSIBLES CONSECUENCIAS QUE TIENE, OSEA UN CASO SE [ELSE]
                                    if (fila_seleccion < modeloTabla.getRowCount()) {
//                                    JOptionPane.showMessageDialog(null, "*18 mik23323e-2");
                                        //Verificamos q ahora la fila seleccion es NODO HIJO
                                        if (modeloTabla.getValueAt(fila_seleccion, columnItem_EnTabla + 8).toString().equals("0")) {
//                                        JOptionPane.showMessageDialog(null, "*19 mik23323e-3");
//                                        if (fila_seleccion < modeloTabla.getRowCount()) {
                                            int longitud_fila_seleccion_Anterior = _extraerItemPresupuesto(fila_seleccion - 1, columnItem_EnTabla).length();
                                            int longitud_fila_seleccion = _extraerItemPresupuesto(fila_seleccion, columnItem_EnTabla).length();
                                            //Si el Nodo Padre y el Nodo Hijo tienen la misma longitud, entonces se deduce que
                                            //el Nodo Hijo no pertenece al Nodo Padre...
                                            if (longitud_fila_seleccion_Anterior + 3 == longitud_fila_seleccion) {
//                                                JOptionPane.showMessageDialog(null, "*20 mik23323e-4");
                                                String item = _extraerItemPresupuesto(fila_seleccion - 1, columnItem_EnTabla);
                                                _escribirItemPresupuesto(item + ".01", fila_seleccion, columnItem_EnTabla);
                                                tblPresupuesto.changeSelection(fila_seleccion, 1, false, false);
                                            } else {
//                                                JOptionPane.showMessageDialog(null, "*21 mik23323e-5");
                                                tblPresupuesto.changeSelection(fila_seleccion, 1, false, false);
                                            }
                                        } else {
                                            //LA FILA SELECCIONADA ES NODO PADRE
                                            //JOptionPane.showMessageDialog(null, "*72 QUITAR-----");
                                            int longitud_fila_seleccion_Anterior = _extraerItemPresupuesto(fila_seleccion - 1, columnItem_EnTabla).length();
                                            int longitud_fila_seleccion = _extraerItemPresupuesto(fila_seleccion, columnItem_EnTabla).length();
                                            //Si el Nodo Padre y el Nodo Hijo tienen la misma longitud, entonces se deduce que
                                            //el Nodo Hijo no pertenece al Nodo Padre...
                                            if (longitud_fila_seleccion_Anterior + 3 == longitud_fila_seleccion) {
//                                                JOptionPane.showMessageDialog(null, "*20 mik23323e-4");
                                                String item = _extraerItemPresupuesto(fila_seleccion - 1, columnItem_EnTabla);
                                                _escribirItemPresupuesto(item + ".01", fila_seleccion, columnItem_EnTabla);
                                                tblPresupuesto.changeSelection(fila_seleccion, 1, false, false);
                                            } else {
//                                                JOptionPane.showMessageDialog(null, "*21 mik23323e-5");
                                                tblPresupuesto.changeSelection(fila_seleccion, 1, false, false);
                                            }
//                                        tblPresupuesto.changeSelection(fila_seleccion-1, 1, false, false);
                                        }
                                    } else {//FIN fila_seleccion+1==modeloTabla.getRowCount()
//                                    if (fila_seleccion<modeloTabla.getRowCount()) {
//                                        tblPresupuesto.changeSelection(fila_seleccion-1, 1, false, false);
//                                    }else{
////                                        tblPresupuesto.changeSelection(fila_seleccion-1, 1, false, false);
//                                    }
                                    }
                                } else {//FIN de itemAnterior sea un Nodo Padre
                                    int fila_actualizar = fila_seleccion;
                                    if (fila_seleccion < modeloTabla.getRowCount()) {
                                        if (modeloTabla.getValueAt(fila_seleccion - 1, columnItem_EnTabla + 8).toString().equals("0")) {
                                            fila_actualizar = encontrarPosicionNodoPadre_aPartirDeNodoHijo(fila_seleccion - 1, modeloTabla);
                                            if (fila_actualizar != -1) {
                                                tblPresupuesto.changeSelection(fila_actualizar, 1, false, false);
                                            }
                                        } else {
                                            tblPresupuesto.changeSelection(fila_actualizar, 1, false, false);
                                        }
                                    } else {
                                        tblPresupuesto.changeSelection(fila_seleccion - 1, 1, false, false);
                                    }
                                    actualizarItems(0);
                                    tblPresupuesto.changeSelection(fila_seleccion - 1, 1, false, false);
                                }
                            } else {
                                //SI no existe la fila anterior
                                //Entonces seleccionamos la primera fila
                                tblPresupuesto.changeSelection(fila_seleccion, 1, false, false);
//                            tblPresupuesto.changeSelection(0, 1, false, false);
                            }
                        }
                    } else {
                        if (fila_seleccion - 1 >= 0) {
//                        tblPresupuesto.changeSelection(fila_seleccion-1, 1, false, false);
                            tblPresupuesto.changeSelection(fila_seleccion - 1, 1, false, false);
                        }
                    }
                }//FIN de NODO HIJO

                System.out.println("$$$$$$$$$ fila_seleccion:" + fila_seleccion + "  modeloTabla.getRowCount():" + modeloTabla.getRowCount());
//            //Una vez eliminado, si la fila_seleccion=a la cantidad de filas de la tabla
//            //entonces seleccionamos la ultima fila de la tabla que es -1 a la fila_seleccion
                if (fila_seleccion == modeloTabla.getRowCount()) {
                    fila_seleccion = fila_seleccion - 1;
                }
                System.out.println("(fila_seleccion+1):" + (fila_seleccion + 1) + "    (fila_seleccion):" + (fila_seleccion) + "  modeloTabla.getRowCount():" + modeloTabla.getRowCount());
//            JOptionPane.showMessageDialog(null, "*22 HOLA");
                actualizarItems(0);
                //Tiene que haber como minimo 1 fila, para que pueda ejecutar el codigo de grabar_presupuesto()
                //Y no tiene que ser la ultima fila
                System.out.println("(fila_seleccion+1):" + (fila_seleccion + 1) + "    (fila_seleccion):" + (fila_seleccion) + "  modeloTabla.getRowCount():" + modeloTabla.getRowCount());
//            if (modeloTabla.getRowCount()!=0 && (fila_seleccion+1)<modeloTabla.getRowCount()) {
//                System.out.println("              INICIO DE grabar_presupuesto(2,0)");
//                dlg_presupuesto_prototipo.grabar_presupuesto(2);
//                System.out.println("              FIN DE grabar_presupuesto(2,0)");
                tblPresupuesto.requestFocus();
//            }else{
//                dlg_presupuesto_prototipo.grabar_presupuesto(2);
//            }
            } else {
                JOptionPane.showMessageDialog(dlg_presupuesto_prototipo, "Seleccione un item");
            }
            //-------------
        } catch (Exception e) {
            e.printStackTrace();
            ClsException._exceptionWriteFile(e, "QuitarNivel-NivelesTable.java");
        }
    }
    //___________________________________________________________________________________ Soy una barra separadora :)

    public boolean generarCodigo(boolean esCapitulo) {
        try {
            System.out.println("========================== GENERAR CODIGO ==========================");
            DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
            int filaSelect = tblPresupuesto.getSelectedRow();
            int cantidadFilas = modeloTabla.getRowCount();
            //Si no se ah seleccionado ninguna fila, por defecto usaremos la ultima fila
            if (filaSelect == -1 && cantidadFilas > 0) {
                filaSelect = cantidadFilas - 1;
                System.out.println("Fila no select: " + filaSelect);
            }
            System.out.println("cantidadFilas:" + cantidadFilas + " -- filaSelect=" + filaSelect);
            String valorFilaAnterior = "";
            Object[] datos = new Object[13];
            boolean sePuedeInsertarLaFilaDeDatos = false;

            if (esCapitulo) {
                int fila_seleccion = tblcapitulosBase.getSelectedRow();
                datos[0] = "0";//idpartida
                datos[2] = tblcapitulosBase.getValueAt(fila_seleccion, 1).toString();//runidad_id ;//descripcion
                datos[3] = "";//unidad
                datos[4] = "";//metrado
                datos[5] = "";//precio_unitario
                datos[6] = "0";//precio_parcial
                datos[7] = "";
                datos[8] = "";
                datos[9] = "1";//tipo//Es Nodo Padre
                datos[10] = "";//rendimiento
                datos[11] = "1";//unidad_id
                datos[12] = dlg_presupuesto_prototipo.codigo_mayor();
            } else {//Cuando es Partida
                int fila_seleccion = tblPartidasBase.getSelectedRow();
                datos[0] = tblPartidasBase.getValueAt(fila_seleccion, 0).toString();//idpartida
                datos[2] = tblPartidasBase.getValueAt(fila_seleccion, 1).toString();//descripcion
                datos[3] = tblPartidasBase.getValueAt(fila_seleccion, 2).toString();//unidad
                datos[4] = "0";//metrado
                datos[5] = metodos.redondeo_3(tblPartidasBase.getValueAt(fila_seleccion, 4), 3, false);//precio_unitario
                datos[6] = "0";//precio_parcial
                datos[7] = "";
                datos[8] = "";
                datos[9] = "0";//tipo//Es Nodo Hijo
                datos[10] = tblPartidasBase.getValueAt(fila_seleccion, 3).toString();//rendimiento
                datos[11] = tblPartidasBase.getValueAt(fila_seleccion, 5).toString();//runidad_id
                datos[12] = dlg_presupuesto_prototipo.codigo_mayor();
            }

            if (cantidadFilas > 0) {//Si ya tiene como minimo una fila hacer...
                String item = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                String item_tipo = modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 8).toString();
//            JOptionPane.showMessageDialog(null, "*68 item="+item);
                int itemNivel = (item.length() + 1) / 3;//Para asegurarnos con el nivel...
//            JOptionPane.showMessageDialog(null, "*69 itemNivel="+itemNivel);

                //TRATAMOS DE CONTROLAR QUE LOS CAPITULOS Y LAS PARTIDAS NO ESTEN EN EL MISMO LUGAR
                if (lasPartidasMismoNivelQCapitulos == false) {
                    //Si los datos vienen de los CAPITULOS, y la fila seleccionada es PARTIDA, entonces...
                    if (esCapitulo && item_tipo.equals("0")) {
//                    sePuedeInsertarLaFilaDeDatos=false;
                        sePuedeInsertarLaFilaDeDatos = true;
//                    JOptionPane.showMessageDialog(null, "*100");
                    } else if (esCapitulo && item_tipo.equals("1")) {
                        //Si los datos vienen de los TITULOS, y la fila seleccionada es TITULO, entonces...
                        sePuedeInsertarLaFilaDeDatos = true;
//                    JOptionPane.showMessageDialog(null, "*101");
                    } else if (!esCapitulo && item_tipo.equals("1")) {
                        //Si los datos vienen de las PARTIDAS, y la fila seleccionada es TITULO, entonces...
                        //Buscamos si la fila seleccionada tiene Nodos Hijos
                        if (tieneNodosHijos(filaSelect, modeloTabla)) {//Si tiene Nodos Hijos
                            //Buscamos si este nodo padre contiene solo Nodos Hijos (Partidas)
                            if (itemPadre_contieneNodosHijos_Partidas(filaSelect, modeloTabla)) {
                                sePuedeInsertarLaFilaDeDatos = true;
//                            JOptionPane.showMessageDialog(null, "*102");
                            } else {//entonces tiene algun elemento Nodo Padre (Capitulo)
                                sePuedeInsertarLaFilaDeDatos = false;
//                            JOptionPane.showMessageDialog(null, "*103");
                            }
                        } else {
                            //Si no tiene Nodos Hijos
                            sePuedeInsertarLaFilaDeDatos = true;
//                        JOptionPane.showMessageDialog(null, "*104");
                        }
                    } else if (!esCapitulo && item_tipo.equals("0")) {
                        //Si los datos vienen de los PARTIDAS, y la fila seleccionada es PARTIDA, entonces...
                        sePuedeInsertarLaFilaDeDatos = true;
//                    JOptionPane.showMessageDialog(null, "*105");
                    }
                } else if (!esCapitulo && item_tipo.equals("0")) {
                    sePuedeInsertarLaFilaDeDatos = true;
//                JOptionPane.showMessageDialog(null, "*106");
                }
//            System.out.println("++++++++++++++++++++++++++++++++++++++++sePuedeInsertarLaFilaDeDatos:"+sePuedeInsertarLaFilaDeDatos);
//            JOptionPane.showMessageDialog(null, "*99 sePuedeInsertarLaFilaDeDatos: "+sePuedeInsertarLaFilaDeDatos);
                if (sePuedeInsertarLaFilaDeDatos) {
                    if (itemNivel <= cantidad_niveles) {
                        boolean insertarCapitulo = false;
                        //SI es capitulo y es de 3er nivel, no permitimos q se inserte
                        if (esCapitulo && itemNivel == cantidad_niveles) {
                            insertarCapitulo = true;
                            dlg_presupuesto_prototipo.habilitar_mensaje(true, "Solo se permiten " + (cantidad_niveles - 1) + " niveles para capítulos y " + (cantidad_niveles) + " niveles para partidas...  id:E13");
//                        return false;
                        }

                        String itemSelect_tipo = modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 8).toString();
                        System.out.println("itemSelect_tipo=" + itemSelect_tipo + "  filaSelect=" + filaSelect + "  tipo=" + modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 8).toString());
                        if (itemSelect_tipo.equals("1") && !esCapitulo) {//Si es nodo Padre y es Partida
//                        JOptionPane.showMessageDialog(null, "*89");
                            //                System.err.println("Es NodoPadre y es Partida__"+_extraerItemPresupuesto(filaSelect, columnItem_EnTabla).toString());
                            //--------------
                            int fila_seleccion_partidaBase = tblPartidasBase.getSelectedRow();
                            String idPartida = tblPartidasBase.getValueAt(fila_seleccion_partidaBase, 0).toString();
                            int filaDelNodoPadre = filaSelect;
                            int fila_tblPresupuesto = filaDelNodoPadre;
                            if (seEncontroEstaPartida_enTitulo(idPartida, fila_tblPresupuesto)) {
                                //Si se repite mostramos un mensaje en el LABEL ya conocido
                                dlg_presupuesto_prototipo.habilitar_mensaje(true, "Ya se encuentra esta partida en el Titulo... id:E19");
                                return false;
                            } else {
                                //Si no se encuentra la partida repetida, entonces se ingresa sin problemas
                                datos[1] = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla).trim() + ".01";//item
                                datos[7] = modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 6).toString().trim();//padre
                                //-----------------------
                                datos[8] = (datos[1].toString().length() + 1) / 3;//nivel
                                //Definimos para el ITEM
                                datos[1] = dlg_presupuesto_prototipo.itemPresupuesto + "." + datos[1];
                                int filaInsertada = filaSelect;
                                modeloTabla.insertRow(filaInsertada + 1, datos);
                                //Seleccionamos la fila del cual va a iniciar el metodo actualzaritems()
                                //Que es la Fila agregada
                                tblPresupuesto.changeSelection(filaInsertada + 1, 1, false, false);
                                actualizarItems(0);
                                return true;
                            }
                            //--------------
                        } else if (itemSelect_tipo.equals("0") && esCapitulo) {//Si es nodo Hijo y es Titulo
//                        JOptionPane.showMessageDialog(null, "*117");
                            //                System.err.println("Es NodoPadre y es Partida__"+_extraerItemPresupuesto(filaSelect, columnItem_EnTabla).toString());
                            int fila_seleccion_capitulosBase = tblcapitulosBase.getSelectedRow();
                            String itemTitulo = tblcapitulosBase.getValueAt(fila_seleccion_capitulosBase, 1).toString();
                            int filaNodoHermanoPadre = encontrarPosicionNodoPadre_aPartirDeNodoHijo(filaSelect, modeloTabla);
                            int fila_tblPresupuesto = filaNodoHermanoPadre;
                            if (seEncontroEsteTitulo_enTitulo(itemTitulo, fila_tblPresupuesto)) {
                                //Si se repite mostramos un mensaje en el LABEL ya conocido
                                dlg_presupuesto_prototipo.habilitar_mensaje(true, "No se puede insertar mas niveles... id:E19");
                                return false;
                            } else {
                                //Si no se encuentra una Titulo repetido, entonces se ingresa sin problemas
                                int filaUltimoNodoHijo = encontrarPosicionNodoHijo_ultimo_aPartirDeNodoHijo(filaSelect, modeloTabla);
//                            System.out.println("NoEs NodoPadre y es esCapitulo="+esCapitulo);
                                valorFilaAnterior = _extraerItemPresupuesto(filaNodoHermanoPadre, columnItem_EnTabla).trim();
                                //                        System.out.println("valorFilaAnterior:"+valorFilaAnterior);
                                int valor = Integer.parseInt(valorFilaAnterior.substring(valorFilaAnterior.length() - 2, valorFilaAnterior.length()));
                                valorFilaAnterior = valorFilaAnterior.substring(0, valorFilaAnterior.length() - 2);
                                valor++;
                                if (String.valueOf(valor).length() == 1) {
                                    valorFilaAnterior = valorFilaAnterior + "0" + valor;
                                } else {
                                    valorFilaAnterior = valorFilaAnterior + "" + valor;
                                }
                                datos[1] = valorFilaAnterior;//item
                                datos[7] = modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 6).toString().trim();//padre
                                //-----------------------
                                datos[8] = (datos[1].toString().length() + 1) / 3;//nivel
                                //Definimos para el ITEM
                                datos[1] = dlg_presupuesto_prototipo.itemPresupuesto + "." + datos[1];
//                            System.out.println("filaUltimoNodoHijo:"+filaUltimoNodoHijo+"   filaSelect:"+filaSelect);
                                int filaInsertada = 0;
                                //Si la filaUltimoNodoHijo es -1, tenemos que seleccionar la filaSelect
                                if (filaUltimoNodoHijo != -1) {
                                    filaInsertada = filaUltimoNodoHijo;
                                } else {
                                    filaInsertada = filaSelect;
                                }
                                modeloTabla.insertRow(filaInsertada + 1, datos);
                                //Seleccionamos la fila del cual va a iniciar el metodo actualzaritems()
                                //Que es la Fila agregada
                                tblPresupuesto.changeSelection(filaInsertada + 1, 1, false, false);
                                actualizarItems(0);
                                return true;
                            }
                            //-----------------------
                        } else if (itemSelect_tipo.equals("0") && !esCapitulo) {//Si es Nodo Hijo y es Partida
//                        JOptionPane.showMessageDialog(null, "*119");
                            //                System.err.println("Es NodoPadre y es Partida__"+_extraerItemPresupuesto(filaSelect, columnItem_EnTabla).toString());
                            int fila_seleccion_partidaBase = tblPartidasBase.getSelectedRow();
                            String idPartida = tblPartidasBase.getValueAt(fila_seleccion_partidaBase, 0).toString();
                            int filaDelNodoPadre = filaSelect;
                            int fila_tblPresupuesto = filaDelNodoPadre;
                            if (seEncontroEstaPartida_enTitulo(idPartida, fila_tblPresupuesto)) {
                                //Si se repite mostramos un mensaje en el LABEL ya conocido
                                dlg_presupuesto_prototipo.habilitar_mensaje(true, "No se puede insertar mas niveles... id:E19");
                                return false;
                            } else {
                                //Si no se encuentra una PARTIDA repetida, entonces se ingresa sin problemas
//                                int filaUltimoNodoHijo = encontrarPosicionNodoHijo_ultimo_aPartirDeNodoHijo(filaSelect, modeloTabla);
                                int filaUltimoNodoHijo = filaSelect;
//                            System.out.println("NoEs NodoPadre y es esCapitulo="+esCapitulo);
                                valorFilaAnterior = _extraerItemPresupuesto(filaDelNodoPadre, columnItem_EnTabla).trim();
                                //                        System.out.println("valorFilaAnterior:"+valorFilaAnterior);
                                int valor = Integer.parseInt(valorFilaAnterior.substring(valorFilaAnterior.length() - 2, valorFilaAnterior.length()));
                                valorFilaAnterior = valorFilaAnterior.substring(0, valorFilaAnterior.length() - 2);
                                valor++;
                                if (String.valueOf(valor).length() == 1) {
                                    valorFilaAnterior = valorFilaAnterior + "0" + valor;
                                } else {
                                    valorFilaAnterior = valorFilaAnterior + "" + valor;
                                }
                                datos[1] = valorFilaAnterior;//item
                                datos[7] = modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 6).toString().trim();//padre
                                //-----------------------
                                datos[8] = (datos[1].toString().length() + 1) / 3;//nivel
                                //Definimos para el ITEM
                                datos[1] = dlg_presupuesto_prototipo.itemPresupuesto + "." + datos[1];
                                System.out.println("filaUltimoNodoHijo:" + filaUltimoNodoHijo + "   filaSelect:" + filaSelect+ " id:01");
                                int filaInsertada = 0;
                                //Si la filaUltimoNodoHijo es -1, tenemos que seleccionar la filaSelect
                                if (filaUltimoNodoHijo != -1) {
                                    filaInsertada = filaUltimoNodoHijo;
                                } else {
                                    filaInsertada = filaSelect;
                                }
                                modeloTabla.insertRow(filaInsertada + 1, datos);
                                //Seleccionamos la fila del cual va a iniciar el metodo actualzaritems()
                                //Que es la Fila agregada
                                tblPresupuesto.changeSelection(filaInsertada + 1, 1, false, false);
                                actualizarItems(0);
                                return true;
                            }
                            //-----------------------
                        } else {//Si es Nodo Hijo
//                        JOptionPane.showMessageDialog(null, "*88");
                            System.out.println("NoEs NodoPadre y es esCapitulo=" + esCapitulo);
                            valorFilaAnterior = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla).trim();
                            System.out.println("valorFilaAnterior:" + valorFilaAnterior);
                            int valor = Integer.parseInt(valorFilaAnterior.substring(valorFilaAnterior.length() - 2, valorFilaAnterior.length()));
                            valorFilaAnterior = valorFilaAnterior.substring(0, valorFilaAnterior.length() - 2);
                            valor++;
                            if (String.valueOf(valor).length() == 1) {
                                valorFilaAnterior = valorFilaAnterior + "0" + valor;
                            } else {
                                valorFilaAnterior = valorFilaAnterior + "" + valor;
                            }
                            datos[1] = valorFilaAnterior;//item
                            datos[7] = modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 6).toString();//padre
                        }
//                    JOptionPane.showMessageDialog(null, "*118");
                        datos[8] = (datos[1].toString().length() + 1) / 3;//nivel
                        //Definimos para el ITEM
                        datos[1] = dlg_presupuesto_prototipo.itemPresupuesto + "." + datos[1];

                        //            cantidadEspacios=numeroEspacios*((Integer)(datos[8])-1);
                        //            datos[1]=cantidadEspacios+datos[1].toString();
                        //Inserta la nueva fila debajo de la fila seleccionada
                        //                modeloTabla.insertRow(filaSelect + 1, datos);
                        int filaInsertada = filaSelect;
                        if (esCapitulo) {
                            //La fila seleccionada tiene nodos hijos
                            if (tieneNodosHijos(filaSelect, modeloTabla)) {
                                //Obtenemos la posicion del ultimo hijo
                                filaInsertada = encontrarPosicionNodoHijo_ultimo_aPartirDeNodoPadre(filaSelect, modeloTabla);
                            }
                        } else {
                        }
                        modeloTabla.insertRow(filaInsertada + 1, datos);
                        //Seleccionamos la fila del cual va a iniciar el metodo actualzaritems()
                        //Que es la Fila agregada
                        tblPresupuesto.changeSelection(filaInsertada + 1, 1, false, false);
                        actualizarItems(0);
                    }
                } else {
                    return false;
                }
            } else {//Si no tiene ninguna fila se le asigna por defecto el 01
//            System.err.println("No hay filas, crearemos uno");
                datos[1] = dlg_presupuesto_prototipo.itemPresupuesto + "." + "01";//item
                datos[7] = "0";//padre
                datos[8] = "1";//nivel
                //Pero antes de eso verificamos si la entrada es una PARTIDA
                //si es asi, entonces no se debe de agregar, o mostrar un mensaje de porq...
                if (esCapitulo) {
                    modeloTabla.addRow(datos);
                    tblPresupuesto.changeSelection(0, 1, false, false);
                } else {//SI ES PARTIDA  la entrada
                    if (lasPartidasMismoNivelQCapitulos) {
                        modeloTabla.addRow(datos);
                        tblPresupuesto.changeSelection(0, 1, false, false);
                    } else {
                        dlg_presupuesto_prototipo.habilitar_mensaje(true, "Debe de ingresar un Capitulo para contener a la partida...");
                        return false;
                    }
                }
            }
            //-------------
        } catch (Exception e) {
            e.printStackTrace();
            ClsException._exceptionWriteFile(e, "GenerarCodigo-NivelesTable.java");
        }
        return true;
    }
    //___________________________________________________________________________________ Soy una barra separadora :)

    public void moverUp() {
        try {
            System.out.println("==============Mover UP================");
            //Seleccionamos la fila seleccionada, jajaja redundancia
            int filaSelect = tblPresupuesto.getSelectedRow();
            //Verificamos que sea mayor que 0,
            if (filaSelect > 0) {
                DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
                String itemI_nodo_tipo = modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 8).toString();
                String itemF_nodo_tipo = modeloTabla.getValueAt(filaSelect - 1, columnItem_EnTabla + 8).toString();
                String aux = "";
                //Obtenemos el valor de la fila anterior,como min valor filaSelect=1, osea la 2da fila
                String itemSelect = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                String itemFinal = _extraerItemPresupuesto(filaSelect - 1, columnItem_EnTabla);
                //Si los 2 items, tienen el mismo nivel (longitud de cadenas)
                if (itemSelect.length() == itemFinal.length()) {
                    //SI el item INICIAL es Nodo Hijo
                    if (itemI_nodo_tipo.equals("0")) {
                        //SI EL ITEM INICIAL ES NODO HIJO, Y RECORDEMOS QUE PASO POR
                        //EL FILTRO DE QUE EL ITEM INICIAL=ITEM FINAL EN LONGITUD
                        //ENTONCES SE DEDUCE QUE EL item Final ES INDISTINTO DE SER
                        // NODO HIJO O NODO PADRE, SE CUMPLIRA LO MISMO
                        aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                        _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect - 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                        _escribirItemPresupuesto(aux, filaSelect - 1, columnItem_EnTabla);
                        modeloTabla.moveRow(filaSelect, filaSelect, filaSelect - 1);
                        tblPresupuesto.changeSelection(filaSelect - 1, 1, false, false);
                    } else {//SI EL ITEM INICIAL ES NODO PADRE
                        //************************************************
//                    JOptionPane.showMessageDialog(null, "*77 MoverUp-SI EL ITEM INICIAL ES NODO PADRE");
                        //Verificamos que no pase del total de filas de la tabla
                        //Si (filaSelect+1)<q la cantidad de filas, entonces hay mas nodos
                        if (filaSelect + 1 < modeloTabla.getRowCount()) {
                            String itemNodoHijo = _extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla);
//                        String itemNodoHijo_tipo=modeloTabla.getValueAt(filaSelect+1, columnItem_EnTabla+8).toString();
                            //Verificamos si itemSelect tiene Nodos Hijos
                            if (itemNodoHijo.length() > itemSelect.length()) {
                                //Buscamos sus Nodos Hijos, y capturamos el ultimo
                                int fila_nuevo_nodo_hijo = filaSelect;
                                do {
                                    fila_nuevo_nodo_hijo++;
                                    System.out.println("  ///////valor  fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "    modeloTabla.getRowCount():" + modeloTabla.getRowCount());
                                    //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                                    if (fila_nuevo_nodo_hijo + 1 >= modeloTabla.getRowCount()) {//Se sale del rango
                                        System.out.println("----break");
                                        break;//Salimos
                                    }
//                                fila_nuevo_nodo_hijo++;
                                    itemNodoHijo = _extraerItemPresupuesto(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla);
                                    System.out.println("itemNodoHijo:" + itemNodoHijo + "    fila_nuevo_nodo_hijo:" + fila_nuevo_nodo_hijo);
                                } while (itemSelect.length() < itemNodoHijo.length());
                                System.out.println("    fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo);
                                //insertamos una fila en>fila_nuevo_nodo_hijo
                                modeloTabla.insertRow(fila_nuevo_nodo_hijo, new Object[modeloTabla.getRowCount()]);
//                            JOptionPane.showMessageDialog(null, "*23 jjj");
                                //movemos a la fila insertada
                                modeloTabla.moveRow(fila_nuevo_nodo_hijo + 1, fila_nuevo_nodo_hijo + 1, fila_nuevo_nodo_hijo);
                                //copiamos los items a itemSelect
                                aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                                _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect - 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                                _escribirItemPresupuesto(aux, filaSelect - 1, columnItem_EnTabla);
//                            JOptionPane.showMessageDialog(null, "*24 ");
                                modeloTabla.moveRow(filaSelect - 1, filaSelect - 1, fila_nuevo_nodo_hijo);
//                            JOptionPane.showMessageDialog(null, "*25");
                                //eliminamos la fila insertada
                                modeloTabla.removeRow(fila_nuevo_nodo_hijo + 1);
                                tblPresupuesto.changeSelection(filaSelect - 1, 1, false, false);
                                actualizarItems(0);
                                return;
                            } else {//itemSelect No tiene Nodos Hijos
                            }
                        } else {
                            //La filaSelect es la ultima fila
                        }
                        //************************************************
                        //SI EL ITEM INICIAL ES NODO PADRE
                        //Si el item FINAL es NODO HIJO
                        if (itemF_nodo_tipo.equals("0")) {
                            aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                            _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect - 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                            _escribirItemPresupuesto(aux, filaSelect - 1, columnItem_EnTabla);
                            modeloTabla.moveRow(filaSelect, filaSelect, filaSelect - 1);
                            tblPresupuesto.changeSelection(filaSelect - 1, 1, false, false);
                        } else if (itemF_nodo_tipo.equals("1")) {//Si el item FINAL es NODO PADRE
//                        JOptionPane.showMessageDialog(null, "*26 df");
                            aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                            _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect - 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                            _escribirItemPresupuesto(aux, filaSelect - 1, columnItem_EnTabla);
                            modeloTabla.moveRow(filaSelect, filaSelect, filaSelect - 1);
                            tblPresupuesto.changeSelection(filaSelect - 1, 1, false, false);
                        }
                    }
                } else if (itemSelect.length() < itemFinal.length()) {
                    //Si No tienen las mismas longitudes y el itemSelect<itemFinal
                    //entonces nos hemos topado con un Nodo Hijo de un item hermano(Item Padre) de itemSelect
                    //Buscamos al Item Hermano (Item Padre)
//                boolean buscarNodoPadre2=false;
                    int fila_nuevo_nodo_hijo = filaSelect;
//                JOptionPane.showMessageDialog(null, "*27 sssss");
                    //VErificamos que no se pase del rango de las filas de la tabla
                    if (filaSelect + 1 < modeloTabla.getRowCount()) {
                        String itemNodoHijo = _extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla);
                        //Verificamos si itemSelect tiene Nodos Hijos
                        if (itemNodoHijo.length() > itemSelect.length()) {
                            //Buscamos sus Nodos Hijos, y capturamos el ultimo
                            do {
                                fila_nuevo_nodo_hijo++;
                                System.out.println("-------++++++++--------valor  fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "    modeloTabla.getRowCount():" + modeloTabla.getRowCount());
                                //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                                if (fila_nuevo_nodo_hijo + 1 >= modeloTabla.getRowCount()) {//Se sale del rango
                                    System.out.println("----break");
                                    break;//Salimos
                                }
                                //                                fila_nuevo_nodo_hijo++;
                                itemNodoHijo = _extraerItemPresupuesto(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla);
                                tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo + 1, 1, false, false);
                                System.out.println("-------++++++++--------itemNodoHijo:" + itemNodoHijo + "    fila_nuevo_nodo_hijo:" + fila_nuevo_nodo_hijo);
//                            JOptionPane.showMessageDialog(null, "*78 itemNodoHijo:"+itemNodoHijo);
                            } while (itemSelect.length() < itemNodoHijo.length());
                            System.out.println("    fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "   " + _extraerItemPresupuesto(fila_nuevo_nodo_hijo, columnItem_EnTabla));
                            tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);
//                        JOptionPane.showMessageDialog(null, "*79 ----itemNodoHijo:"+itemNodoHijo);

                            //MKMKMKMKMKMKMKMK
                            //Buscamos el Nodo hermano
                            //                int fila_nuevo_nodo_padre=filaSelect;
                            //                do {
                            //                    //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                            //                    if (fila_nuevo_nodo_padre-1<0) {//Se sale del rango
                            //                        System.out.println("---------break");
                            //                        break;
                            //                    }
                            //                    itemFinal=_extraerItemPresupuesto(fila_nuevo_nodo_padre-1, columnItem_EnTabla);
                            //                    System.out.println("itemFinal:"+itemFinal+"   fila_nuevo_nodo_padre:"+fila_nuevo_nodo_padre);
                            //                    fila_nuevo_nodo_padre--;
                            //                }while (itemSelect.length()<itemFinal.length());
                            //                System.out.println("  fila_nuevo_nodo_padre:"+fila_nuevo_nodo_padre);
                            //
                            //                    //Verificamos que los itemSelect y itemHermano(Padre), sean del mismo nivel
                            //                    if (itemSelect.length()==_extraerItemPresupuesto(fila_nuevo_nodo_hijo, columnItem_EnTabla).length()) {
                            //                        //Entonces los 2 son iguales en longitud
                            //
                            //                    } else {
                            //                        //Los 2 no son iguales y no tienen el mismo nivel
                            //                        //No se hace nada
                            //                    }
                            //
                            //                    //insertamos una fila en>fila_nuevo_nodo_hijo
                            //                    modeloTabla.insertRow(fila_nuevo_nodo_hijo, new Object[modeloTabla.getRowCount()]);
                            //                    tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);
                            //    //                                JOptionPane.showMessageDialog(null, "*28 insertRow 3");
                        }
                    } else {
                        //Entonces estamos hablando de la ultima fila de la tabla
//                    buscarNodoPadre2=true;
                    }

                    //BUSCAMOS HACIA ARRIBA EL NODO PADRE
                    //Buscamos el Nodo hermano
                    int fila_nuevo_nodo_padre = filaSelect;
                    do {
                        //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                        if (fila_nuevo_nodo_padre - 1 < 0) {//Se sale del rango
                            System.out.println("---------break");
                            break;
                        }
                        itemFinal = _extraerItemPresupuesto(fila_nuevo_nodo_padre - 1, columnItem_EnTabla);
                        System.out.println("itemFinal:" + itemFinal + "   fila_nuevo_nodo_padre:" + fila_nuevo_nodo_padre);
                        fila_nuevo_nodo_padre--;
                    } while (itemSelect.length() < itemFinal.length());
                    System.out.println("  fila_nuevo_nodo_padre:" + fila_nuevo_nodo_padre);
                    aux = _extraerItemPresupuesto(fila_nuevo_nodo_padre, columnItem_EnTabla);
                    _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect, columnItem_EnTabla), fila_nuevo_nodo_padre, columnItem_EnTabla);
                    _escribirItemPresupuesto(aux, filaSelect, columnItem_EnTabla);
                    //JOptionPane.showMessageDialog(null, "*29 ");
                    //insertamos una fila para manejarlo mejor
                    modeloTabla.insertRow(fila_nuevo_nodo_padre, new Object[modeloTabla.getRowCount()]);
                    //
                    //JOptionPane.showMessageDialog(null, "*30 insertRow");
//                modeloTabla.moveRow(fila_nuevo_nodo_padre, fila_nuevo_nodo_padre, filaSelect+1);
                    modeloTabla.moveRow(filaSelect + 1, fila_nuevo_nodo_hijo + 1, fila_nuevo_nodo_padre);
//                tblPresupuesto.changeSelection(filaSelect, 1, false, false);
                    tblPresupuesto.changeSelection(fila_nuevo_nodo_padre + fila_nuevo_nodo_hijo - filaSelect + 1, 1, false, false);
                    //JOptionPane.showMessageDialog(null, "*31 moveRow");
                    //Removemos el insert fila que hemos hecho
                    modeloTabla.removeRow(fila_nuevo_nodo_padre + fila_nuevo_nodo_hijo - filaSelect + 1);
                    tblPresupuesto.changeSelection(fila_nuevo_nodo_padre, 1, false, false);
                    actualizarItems(0);
                } else {

                    metodos.sonidoBeep();
                }
            } else {
                metodos.sonidoBeep();
            }
            //-------------
        } catch (Exception e) {
            e.printStackTrace();
            ClsException._exceptionWriteFile(e, "MoverUp-NivelesTable.java");
        }
    }

    public void moverDown() {
        try {
            System.out.println("==============Mover DOWN================");
            int filaSelect = tblPresupuesto.getSelectedRow();
            DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
            if (filaSelect + 1 < modeloTabla.getRowCount() && filaSelect != -1) {
                String itemI_nodo_tipo = modeloTabla.getValueAt(filaSelect, columnItem_EnTabla + 8).toString();
                String itemF_nodo_tipo = modeloTabla.getValueAt(filaSelect + 1, columnItem_EnTabla + 8).toString();
                String aux = "";
                //Obtenemos el valor de la fila anterior,como min valor filaSelect=1, osea la 2da fila
                String itemSelect = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                String itemFinal = _extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla);
                //Si los 2 items, tienen el mismo nivel (longitud de cadenas)
                if (itemSelect.length() == itemFinal.length()) {
                    //SI el item INICIAL es Nodo Hijo
                    if (itemI_nodo_tipo.equals("0")) {//======================================================================
                        //SI el item final es Nodo Hijo
                        if (itemF_nodo_tipo.equals("0")) {
                            //JOptionPane.showMessageDialog(null, "*72 DOWN Nodos Hijos");
                            aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                            _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                            _escribirItemPresupuesto(aux, filaSelect + 1, columnItem_EnTabla);
                            modeloTabla.moveRow(filaSelect, filaSelect, filaSelect + 1);
//                        moverFila(filaSelect, filaSelect- 1);
                            tblPresupuesto.changeSelection(filaSelect + 1, 1, false, false);
                        } else if (itemF_nodo_tipo.equals("1")) {
                            //SI el item final es Nodo Padre
                            //**************************************************************
                            //Verificamos que no pase del total de filas
                            //Si (filaSelect+2)<q la cantidad de filas, entonces hay mas nodos
                            if (filaSelect + 1 < modeloTabla.getRowCount()) { //Antes era +2
                                String itemNodoHijo = _extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla);
                                //Verificamos si itemSelect tiene Nodos Hijos
                                if (itemNodoHijo.length() > itemSelect.length()) {
                                    //Buscamos sus Nodos Hijos, y capturamos el ultimo
                                    int fila_nuevo_nodo_hijo = filaSelect + 1;
                                    do {
                                        fila_nuevo_nodo_hijo++;
                                        System.out.println("  ///////valor  fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "    modeloTabla.getRowCount():" + modeloTabla.getRowCount());
                                        //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                                        if (fila_nuevo_nodo_hijo + 1 >= modeloTabla.getRowCount()) {//Se sale del rango
                                            System.out.println("----break");
                                            break;//Salimos
                                        }
                                        //                                fila_nuevo_nodo_hijo++;
                                        itemNodoHijo = _extraerItemPresupuesto(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla);
                                        System.out.println("itemNodoHijo:" + itemNodoHijo + "    fila_nuevo_nodo_hijo:" + fila_nuevo_nodo_hijo);
                                    } while (itemSelect.length() < itemNodoHijo.length());
                                    System.out.println("    fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo);

                                    //insertamos una fila en>fila_nuevo_nodo_hijo
                                    modeloTabla.insertRow(fila_nuevo_nodo_hijo, new Object[modeloTabla.getRowCount()]);
                                    tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);
//                                JOptionPane.showMessageDialog(null, "*31 insertRow 3");
                                    //copiamos los items a itemSelect
//                                aux=_extraerItemPresupuesto(fila_nuevo_nodo_hijo+1, columnItem_EnTabla);
//                                System.out.println("aux:"+aux);
                                    aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
//                                System.out.println("aux:"+aux);
                                    _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                                    _escribirItemPresupuesto(aux, filaSelect + 1, columnItem_EnTabla);
//                                tblPresupuesto.changeSelection(filaSelect+1, 1, false, false);
//                                JOptionPane.showMessageDialog(null, "*32");
                                    //movemos a la fila insertada
                                    modeloTabla.moveRow(fila_nuevo_nodo_hijo, fila_nuevo_nodo_hijo, fila_nuevo_nodo_hijo + 1);
//                                JOptionPane.showMessageDialog(null, "*33 moveRow fila_nuevo_nodo_hijo 4");
                                    //movemos a la fila insertada
                                    modeloTabla.moveRow(filaSelect, filaSelect, fila_nuevo_nodo_hijo);
//                                tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo+1, 1, false, false);
//                                JOptionPane.showMessageDialog(null, "*34 moveRow 4");
                                    //eliminamos la fila insertada
                                    modeloTabla.removeRow(fila_nuevo_nodo_hijo + 1);
                                    tblPresupuesto.changeSelection(filaSelect, 1, false, false);
                                    actualizarItems(0);
                                    tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);

                                } else {//itemSelect No tiene Nodos Hijos
                                    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                                    aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                                    _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                                    _escribirItemPresupuesto(aux, filaSelect + 1, columnItem_EnTabla);
                                    modeloTabla.moveRow(filaSelect, filaSelect, filaSelect + 1);
                                    tblPresupuesto.changeSelection(filaSelect + 1, 1, false, false);
                                    actualizarItems(0);
                                }
                            } else {
                                //La filaSelect es la ultima fila
                                metodos.sonidoBeep();
                            }
                        }
                    } else {//SI EL ITEM INICIAL ES NODO PADRE ===============================================================
                        //Si el item FINAL es Nodo Hijo
                        if (itemF_nodo_tipo.equals("0")) {
                            modeloTabla.insertRow(filaSelect, new Object[modeloTabla.getColumnCount()]);
//                        JOptionPane.showMessageDialog(null, "*35 DOWN I=p F=h");
                            aux = _extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla);
                            _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect + 2, columnItem_EnTabla), filaSelect + 1, columnItem_EnTabla);
                            modeloTabla.moveRow(filaSelect + 2, filaSelect + 2, filaSelect);
                            _escribirItemPresupuesto(aux, filaSelect, columnItem_EnTabla);
                            modeloTabla.removeRow(filaSelect + 1);
                            tblPresupuesto.changeSelection(filaSelect + 1, 1, false, false);
                        } else {//SI EL ITEM INICIAL ES NODO PADRE
                            //Si el item FINAL es Nodo PADRE
                            String itemComparar = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                            //**************************************************************
                            //Verificamos que no pase del total de filas
                            //Si (filaSelect+2)<q la cantidad de filas, entonces hay mas nodos
                            if (filaSelect + 1 < modeloTabla.getRowCount()) {
//                            JOptionPane.showMessageDialog(null, "*73 DOWN I=p F=p");
                                String itemNodoHijo = _extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla);
                                //Verificamos si itemSelect tiene Nodos Hijos
                                if (itemNodoHijo.length() > itemSelect.length()) {
                                    //Buscamos sus Nodos Hijos, y capturamos el ultimo
                                    int fila_nuevo_nodo_hijo = filaSelect + 1;
                                    do {
                                        fila_nuevo_nodo_hijo++;
                                        System.out.println("..................///////valor  fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "    modeloTabla.getRowCount():" + modeloTabla.getRowCount());
                                        //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                                        if (fila_nuevo_nodo_hijo + 1 >= modeloTabla.getRowCount()) {//Se sale del rango
                                            System.out.println("----break");
                                            break;//Salimos
                                        }
                                        //                                fila_nuevo_nodo_hijo++;
                                        itemNodoHijo = _extraerItemPresupuesto(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla);
                                        System.out.println("..................itemNodoHijo:" + itemNodoHijo + "    fila_nuevo_nodo_hijo:" + fila_nuevo_nodo_hijo);
                                    } while (itemSelect.length() < itemNodoHijo.length());
                                    System.out.println("..................fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo);
                                    //insertamos una fila en>fila_nuevo_nodo_hijo
                                    modeloTabla.insertRow(fila_nuevo_nodo_hijo, new Object[modeloTabla.getRowCount()]);
                                    tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);
                                    //JOptionPane.showMessageDialog(null, "*36 insertRow 3");
                                    //copiamos los items a itemSelect
                                    //                                aux=_extraerItemPresupuesto(fila_nuevo_nodo_hijo+1, columnItem_EnTabla);
                                    //                                System.out.println("aux:"+aux);
                                    aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                                    System.out.println("aux:" + aux);
                                    _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                                    _escribirItemPresupuesto(aux, filaSelect + 1, columnItem_EnTabla);
                                    tblPresupuesto.changeSelection(filaSelect + 1, 1, false, false);
                                    //JOptionPane.showMessageDialog(null, "*37");
                                    //movemos a la fila insertada
                                    modeloTabla.moveRow(fila_nuevo_nodo_hijo, fila_nuevo_nodo_hijo, fila_nuevo_nodo_hijo + 1);
                                    //JOptionPane.showMessageDialog(null, "*38 moveRow fila_nuevo_nodo_hijo 4");
                                    //movemos a la fila insertada
                                    modeloTabla.moveRow(filaSelect, filaSelect, fila_nuevo_nodo_hijo);
                                    tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo + 1, 1, false, false);
                                    //JOptionPane.showMessageDialog(null, "*39 moveRow 4");
                                    //eliminamos la fila insertada
                                    modeloTabla.removeRow(fila_nuevo_nodo_hijo + 1);
                                    tblPresupuesto.changeSelection(filaSelect, 1, false, false);
                                    actualizarItems(0);
                                    tblPresupuesto.changeSelection(filaSelect + 1, 1, false, false);//Po siacaso
                                    actualizarItems(0);//Po siacaso
                                    tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);
                                } else {//itemSelect No tiene Nodos Hijos
//                                JOptionPane.showMessageDialog(null, "*74 DOWN I=p,No tiene Nodos Hijos F=p");
                                    //Entonces es problable que (Y creo que la condicion del IF de arriba
                                    //esta por demas, pues se supone que los dos items son Nodo Padre)
                                    //VERIFICAMOS QUE EL ITEM FINAL SEA PADRE, AUNQ ES POR GUSTO, JAJAJA
                                    if (modeloTabla.getValueAt(filaSelect + 1, columnItem_EnTabla + 8).toString().equals("1")) {
                                        //buscamos sus nodos hijos del itemFinal, para obtener el ultimo
                                        //y recien mover el itemSeleccionado a esa fila mas 1 creo...
                                        //VALIDAMOS QUE LA FILA EXISTA, La fila+1 no tiene que pasar del rango
//                                    JOptionPane.showMessageDialog(null, "*82 ");
                                        if (filaSelect + 2 < modeloTabla.getRowCount()) {
                                            //Buscamos sus Nodos Hijos, y capturamos el ultimo
                                            tblPresupuesto.changeSelection(filaSelect + 2, 1, false, false);
//                                        JOptionPane.showMessageDialog(null, "*60 DOWN I=p F=p,Buscamos sus Nodos Hijos");
                                            int fila_nuevo_nodo_hijo = filaSelect;
                                            tblPresupuesto.changeSelection(filaSelect, 1, false, false);
//                                        JOptionPane.showMessageDialog(null, "*75 DOWN I=p F=p");
                                            do {
                                                fila_nuevo_nodo_hijo++;
                                                System.out.println("rtrt///////valor  fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "    modeloTabla.getRowCount():" + modeloTabla.getRowCount());
                                                //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                                                if (fila_nuevo_nodo_hijo + 1 >= modeloTabla.getRowCount()) {//Se sale del rango
                                                    System.out.println("----break");
                                                    break;//Salimos
                                                }
                                                //                                fila_nuevo_nodo_hijo++;
                                                tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo + 1, 1, false, false);
//                                            JOptionPane.showMessageDialog(null, "*61 es un nodo hijo");
                                                itemNodoHijo = _extraerItemPresupuesto(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla);
                                                System.out.println(">itemSelect:" + itemSelect + "   itemNodoHijo:" + itemNodoHijo + "    fila_nuevo_nodo_hijo:" + fila_nuevo_nodo_hijo);
//                                            fila_nuevo_nodo_hijo++;
                                            } while (itemSelect.length() < itemNodoHijo.length());

                                            System.out.println("    fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "   _extraerItemPresupuesto(fila_nuevo_nodo_hijo, 1):" + _extraerItemPresupuesto(fila_nuevo_nodo_hijo, columnItem_EnTabla));
                                            //vemos si tiene nodos hijos el itemSelect, q
//                                        if (itemSelect.equals(_extraerItemPresupuesto(fila_nuevo_nodo_hijo-2, columnItem_EnTabla))) {
//                                            JOptionPane.showMessageDialog(null, "*76 DOWN iguales");
//                                        } else {
//                                        }
                                            modeloTabla.insertRow(fila_nuevo_nodo_hijo + 1, new Object[modeloTabla.getRowCount()]);
                                            tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo + 1, 1, false, false);
//                                        JOptionPane.showMessageDialog(null, "*107");
                                            //Movemos l item seleccionado
                                            modeloTabla.moveRow(filaSelect, filaSelect, fila_nuevo_nodo_hijo);
                                            tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);
//                                        JOptionPane.showMessageDialog(null, "*108");
                                            modeloTabla.removeRow(fila_nuevo_nodo_hijo + 1);
                                            tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);
//                                        JOptionPane.showMessageDialog(null, "*109");

                                            //++++++++++++++++++++++++++++++++++++++
                                            //PARA ACTUALIZAR LOS ITEMS
                                            int fila = 0;
                                            //Buscamos en la parte superior, un item del mismo nivel del item seleccionado
                                            if (filaSelect == 0) {
                                                fila = filaSelect;
                                                _escribirItemPresupuesto("01", fila, columnItem_EnTabla);
                                            } else {
                                                fila = filaSelect - 1;
                                            }
                                            if (filaSelect >= 0) {
//                                            fila=filaSelect-1;
                                                String itemHijo = _extraerItemPresupuesto(fila, columnItem_EnTabla).toString();
                                                if (modeloTabla.getValueAt(fila, columnItem_EnTabla + 8).toString().equals("1") && itemHijo.length() == itemComparar.length() - 3) {
                                                    System.out.println("++++++++++++++++++++itemSelect:" + itemSelect + "  item delaFilaSeleccionada:" + _extraerItemPresupuesto(filaSelect, columnItem_EnTabla));
                                                    //                                JOptionPane.showMessageDialog(null, "*76 itemSelect "+itemSelect);
                                                    //El itemDisminuido (osea si tenia: 02.02 ---> ahora disminuye a: 02, tiene que ser
                                                    //diferente al obtenido por la fila_seleccionada, por que si es igual se le agregaria el .01
                                                    //y con esto no se habria disminuido el item para nada...
                                                    //pero si son diferentes entonces al mover el item afectado, en la fila: fila_seleccionada
                                                    //garantizamos que no se trata del mismo item, y a este se le agrega el .01
                                                    if (!itemSelect.equals(_extraerItemPresupuesto(filaSelect, columnItem_EnTabla))) {
                                                        itemComparar = itemHijo + ".01";
                                                        _escribirItemPresupuesto(itemComparar, fila + 1, columnItem_EnTabla);
                                                    }
                                                } else {
                                                    //tener encuenta que itemSelect==itemComparar
                                                    while (itemComparar.length() < itemHijo.length()) {
                                                        if (modeloTabla.getValueAt(fila, columnItem_EnTabla + 8).toString().equals("1") && itemHijo.length() == itemComparar.length() - 3) {
                                                            itemComparar = itemHijo + ".01";
                                                            _escribirItemPresupuesto(itemComparar, filaSelect, columnItem_EnTabla);
                                                            break;
                                                        } else {
                                                            if (fila - 1 < 0) {
                                                                break;
                                                            }
                                                            fila--;
                                                            itemHijo = _extraerItemPresupuesto(fila, columnItem_EnTabla);
                                                        }
                                                    }
                                                }
                                                tblPresupuesto.changeSelection(fila + 1, 1, false, false);
                                                //                            JOptionPane.showMessageDialog(null, "*9 FILA");
                                                actualizarItems(0);
                                                tblPresupuesto.changeSelection(fila, 1, false, false);
                                                actualizarItems(0);
                                                //colocamos el focus, a la fila movida, para hacerle entender al usuario q se movio el item
                                                tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo, 1, false, false);
                                                actualizarItems(0);
                                                //++++++++++++++++++++++++++++++++++++++
                                            } else {
                                            }
                                            //                fila_nuevo_nodo_hijo=modeloTabla.getRowCount();
                                            //                System.out.println("    fila_nuevo_nodo_hijo>"+fila_nuevo_nodo_hijo);
                                            //                modeloTabla.insertRow(fila_nuevo_nodo_hijo, new Object[modeloTabla.getRowCount()]);
                                        } else {
//                                        JOptionPane.showMessageDialog(null, "*83 ");
                                            aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                                            _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                                            _escribirItemPresupuesto(aux, filaSelect + 1, columnItem_EnTabla);
                                            modeloTabla.moveRow(filaSelect, filaSelect, filaSelect + 1);
                                            tblPresupuesto.changeSelection(filaSelect + 1, 1, false, false);
                                        }
                                    } else {
                                    }
                                    //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//                                aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
//                                _escribirItemPresupuesto(_extraerItemPresupuesto(filaSelect+1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
//                                _escribirItemPresupuesto(aux, filaSelect+1, columnItem_EnTabla);
//                                modeloTabla.moveRow(filaSelect, filaSelect, filaSelect+1);
//                                tblPresupuesto.changeSelection(filaSelect+1, 1,false,false);
//                                actualizarItems(0);
                                }
                            } else {
                                //La filaSelect es la ultima fila
                                //JOptionPane.showMessageDialog(null, "*81 mk");
                            }
                        }
                    }
                } else if (itemSelect.length() < itemFinal.length()) {
                    //Si No tienen las mismas longitudes y el itemFinal > itemSelect
                    //entonces nos hemos topado con un Nodo Hijo de un item hermano de itemSelect
                    //02.02
                    //
                    //Buscamos el Nodo hermano

                    //**************************************************************
                    //Verificamos que no pase del total de filas
                    //Si (filaSelect+1)<q la cantidad de filas, entonces hay mas nodos
                    if (filaSelect + 1 < modeloTabla.getRowCount()) {
                        String itemNodoHijo = _extraerItemPresupuesto(filaSelect + 1, columnItem_EnTabla);
                        //Verificamos si itemSelect tiene Nodos Hijos
                        if (itemNodoHijo.length() > itemSelect.length()) {
                            //Buscamos sus Nodos Hijos, y capturamos el ultimo
                            int fila_nuevo_nodo_hijo = filaSelect;
                            do {
                                fila_nuevo_nodo_hijo++;
                                System.out.println("  ///////valor  fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "    modeloTabla.getRowCount():" + modeloTabla.getRowCount());
                                //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                                if (fila_nuevo_nodo_hijo + 1 >= modeloTabla.getRowCount()) {//Se sale del rango
                                    System.out.println("----break");
                                    break;//Salimos
                                }
//                                fila_nuevo_nodo_hijo++;
                                itemNodoHijo = _extraerItemPresupuesto(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla);
                                System.out.println("itemNodoHijo:" + itemNodoHijo + "    fila_nuevo_nodo_hijo:" + fila_nuevo_nodo_hijo);
                            } while (itemSelect.length() < itemNodoHijo.length());
                            System.out.println("    fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo);
                            //VErificamos que esten en el mismo nivel
                            if (itemSelect.length() <= itemNodoHijo.length()) {
                                //Verificamos que este en el rango
                                if (fila_nuevo_nodo_hijo + 1 < modeloTabla.getRowCount()) {
                                    String itemNodoHijo_tipo = modeloTabla.getValueAt(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla + 8).toString();
                                    //SI itemNodoHijo ES UN NODO HIJO
                                    if (itemNodoHijo_tipo.equals("0")) {
                                        //copiamos los items a itemSelect
                                        //                                aux=_extraerItemPresupuesto(fila_nuevo_nodo_hijo+1, columnItem_EnTabla);
                                        //                                System.out.println("aux:"+aux);
                                        aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
                                        //                                System.out.println("aux:"+aux);
                                        _escribirItemPresupuesto(_extraerItemPresupuesto(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                                        _escribirItemPresupuesto(aux, fila_nuevo_nodo_hijo + 1, columnItem_EnTabla);
                                        tblPresupuesto.changeSelection(fila_nuevo_nodo_hijo + 1, 1, false, false);
                                        //                                JOptionPane.showMessageDialog(null, "*40");
                                        //insertamos una fila en>fila_nuevo_nodo_hijo
                                        modeloTabla.insertRow(filaSelect, new Object[modeloTabla.getRowCount()]);
                                        tblPresupuesto.changeSelection(filaSelect, 1, false, false);
                                        //                                JOptionPane.showMessageDialog(null, "*41 insertRow 3");
                                        //movemos a la fila insertada
                                        modeloTabla.moveRow(fila_nuevo_nodo_hijo + 2, fila_nuevo_nodo_hijo + 2, filaSelect);
                                        tblPresupuesto.changeSelection(filaSelect, 1, false, false);
                                        //                                JOptionPane.showMessageDialog(null, "*42 moveRow 4");
                                        //eliminamos la fila insertada
                                        modeloTabla.removeRow(filaSelect + 1);
                                        tblPresupuesto.changeSelection(filaSelect + 1, 1, false, false);
                                        actualizarItems(0);
                                    } else if (itemNodoHijo_tipo.equals("1")) {
                                        //SI itemNodoHijo ES UN NODO PADRE
                                        //------------------------------------------------------
                                        int fila_nuevo_nodo_padre2 = fila_nuevo_nodo_hijo;
                                        //Buscamos sus Nodos Hijos, y capturamos el ultimo
//                                    fila_nuevo_nodo_hijo=filaSelect;
                                        do {
                                            fila_nuevo_nodo_hijo++;
                                            System.out.println("----------->>>///////valor  fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo + "    modeloTabla.getRowCount():" + modeloTabla.getRowCount());
                                            //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
                                            if (fila_nuevo_nodo_hijo + 1 >= modeloTabla.getRowCount()) {//Se sale del rango
                                                System.out.println("----break");
                                                break;//Salimos
                                            }
                                            //                                fila_nuevo_nodo_hijo++;
                                            itemNodoHijo = _extraerItemPresupuesto(fila_nuevo_nodo_hijo + 1, columnItem_EnTabla);
                                            System.out.println("----------->>>itemNodoHijo:" + itemNodoHijo + "    fila_nuevo_nodo_hijo:" + fila_nuevo_nodo_hijo);
                                        } while (itemSelect.length() < itemNodoHijo.length());
                                        System.out.println("----------->>>fila_nuevo_nodo_hijo>" + fila_nuevo_nodo_hijo);
                                        //insert fila
                                        modeloTabla.insertRow(fila_nuevo_nodo_hijo, new Object[modeloTabla.getRowCount()]);
                                        //cambiamos la fila de
                                        modeloTabla.moveRow(fila_nuevo_nodo_hijo + 1, fila_nuevo_nodo_hijo + 1, fila_nuevo_nodo_hijo);
                                        //copiamos los items a itemSelect
                                        aux = _extraerItemPresupuesto(filaSelect, columnItem_EnTabla);
//                                    System.out.println("aux:"+aux);
                                        _escribirItemPresupuesto(_extraerItemPresupuesto(fila_nuevo_nodo_padre2 + 1, columnItem_EnTabla), filaSelect, columnItem_EnTabla);
                                        tblPresupuesto.changeSelection(filaSelect, 1, false, false);
//                                    JOptionPane.showMessageDialog(null, "*43");
                                        _escribirItemPresupuesto(aux, fila_nuevo_nodo_padre2 + 1, columnItem_EnTabla);
                                        tblPresupuesto.changeSelection(fila_nuevo_nodo_padre2 + 1, 1, false, false);
//                                    JOptionPane.showMessageDialog(null, "*44");
                                        //movemos a la fila insertada
                                        System.out.println("filaSelect:" + filaSelect + "    fila_nuevo_nodo_padre2:" + fila_nuevo_nodo_padre2 + "  (fila_nuevo_nodo_padre2-1):" + (fila_nuevo_nodo_padre2 - 1) + "   fila_nuevo_nodo_hijo:" + fila_nuevo_nodo_hijo);
                                        modeloTabla.moveRow(filaSelect, fila_nuevo_nodo_padre2, filaSelect + fila_nuevo_nodo_hijo - fila_nuevo_nodo_padre2 + 1);
//                                    tblPresupuesto.changeSelection(filaSelect+fila_nuevo_nodo_hijo-fila_nuevo_nodo_padre2+1, 1, false, false);
//                                    //JOptionPane.showMessageDialog(null, "*45 moveRow 4");
                                        //Eliminamos la fila insertada
                                        modeloTabla.removeRow(filaSelect + fila_nuevo_nodo_hijo - fila_nuevo_nodo_padre2);
                                        tblPresupuesto.changeSelection(filaSelect, 1, false, false);//necesario
                                        actualizarItems(0);
                                        tblPresupuesto.changeSelection(filaSelect + fila_nuevo_nodo_hijo - fila_nuevo_nodo_padre2, 1, false, false);//necesario
                                        //------------------------------------------------------
                                    }
                                } else {
                                    metodos.sonidoBeep();
                                }
                            } else {
                                //No son del mismo nivel
                                //CREO Q FINALIZA, JAJAJAJA
                                metodos.sonidoBeep();
                            }
                        } else {//itemSelect No tiene Nodos Hijos
                        }
                    } else {
                        //La filaSelect es la ultima fila
                    }
                    //**************************************************************

//                int fila_nuevo_nodo_padre=filaSelect;
//                do {
//                    //Si se cumple la condicion del while, quiere decir q existe Nodos Hijos
//                    if (fila_nuevo_nodo_padre+1>modeloTabla.getRowCount()) {//Se sale del rango
//                        break;
//                    }
//                    itemFinal=_extraerItemPresupuesto(fila_nuevo_nodo_padre+1, columnItem_EnTabla);
//                    fila_nuevo_nodo_padre++;
//                }while (itemSelect.length()<itemFinal.length());
                }
            } else {
                metodos.sonidoBeep();
            }
            //-------------
        } catch (Exception e) {
            e.printStackTrace();
            ClsException._exceptionWriteFile(e, "MoverDown-NivelesTable.java");
        }
    }
    //___________________________________________________________________________________ Soy una barra separadora :)

    public boolean tieneNodosHijos(int filaPadre, DefaultTableModel modeloTabla) {
        //Buscamos sus nodos hijos en la parte inferior de la filaPadre
        //Estos nodos hijos deben de ser niveles mayores al del padre
        if (filaPadre + 1 < modeloTabla.getRowCount()) {//Verificamos que no pase del total de filas de la tabla
            //entonces existe la filaPadre+1
            //Verificamos que sea mayor al padre original
            String itemPadre = _extraerItemPresupuesto(filaPadre, columnItem_EnTabla);
            String itemHijo = _extraerItemPresupuesto(filaPadre + 1, columnItem_EnTabla);
            if (itemPadre.length() < itemHijo.length()) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }

    public int encontrarPosicionNodoPadre_aPartirDeNodoHijo(int filaNodoHijo, DefaultTableModel modeloTabla) {
        String itemHijo = _extraerItemPresupuesto(filaNodoHijo, columnItem_EnTabla);
//        String itemPadre="";
        String itemAux = "";
        int fila_posicionNodoPadre = filaNodoHijo;
        //Que no pase de cero
        if (filaNodoHijo - 1 >= 0) {
            fila_posicionNodoPadre--;
            itemAux = _extraerItemPresupuesto(filaNodoHijo - 1, columnItem_EnTabla);
            while (itemHijo.length() <= itemAux.length()) {
                if (fila_posicionNodoPadre - 1 < 0) {
                    break;
                }
                fila_posicionNodoPadre--;
                itemAux = _extraerItemPresupuesto(fila_posicionNodoPadre, columnItem_EnTabla);
            }
            return fila_posicionNodoPadre;
        }
        return -1;
    }

    public int encontrarPosicionNodoHijo_ultimo_aPartirDeNodoPadre(int filaNodoPadre, DefaultTableModel modeloTabla) {
        String itemPadre = _extraerItemPresupuesto(filaNodoPadre, columnItem_EnTabla);
        String itemHijo = "";
//        String itemAux="";
        int fila_posicionNodoHijoUltimo = filaNodoPadre;
        //Que no pase de la ultima fila
        if (filaNodoPadre + 1 < modeloTabla.getRowCount()) {
//                fila_posicionNodoHijoUltimo++;
            itemHijo = _extraerItemPresupuesto(filaNodoPadre + 1, columnItem_EnTabla);
            while (itemPadre.length() < itemHijo.length()) {
                fila_posicionNodoHijoUltimo++;
                if (fila_posicionNodoHijoUltimo + 1 >= modeloTabla.getRowCount()) {
                    break;
                }
//                    fila_posicionNodoHijoUltimo++;
                itemHijo = _extraerItemPresupuesto(fila_posicionNodoHijoUltimo + 1, columnItem_EnTabla);
            }
            return fila_posicionNodoHijoUltimo;
        }
        return -1;
    }

    public int encontrarPosicionNodoHijo_ultimo_aPartirDeNodoHijo(int filaNodoHijo, DefaultTableModel modeloTabla) {
        String itemPadre = _extraerItemPresupuesto(filaNodoHijo, columnItem_EnTabla);
        String itemHijo = "";
//        String itemAux="";
        int fila_posicionNodoHijoUltimo = filaNodoHijo;
        //Que no pase de la ultima fila
        if (filaNodoHijo + 1 < modeloTabla.getRowCount()) {
            itemHijo = _extraerItemPresupuesto(filaNodoHijo + 1, columnItem_EnTabla);
            while (itemPadre.length() <= itemHijo.length()) {
                fila_posicionNodoHijoUltimo++;
                if (fila_posicionNodoHijoUltimo + 1 >= modeloTabla.getRowCount()) {
                    break;
                }
//                    fila_posicionNodoHijoUltimo++;
                itemHijo = _extraerItemPresupuesto(fila_posicionNodoHijoUltimo + 1, columnItem_EnTabla);
            }
            return fila_posicionNodoHijoUltimo;
        }
        return filaNodoHijo;
//        return -1;
    }

    public int encontrarElMayorNivel_aPartirDeNodoPadre(int filaNodoPadre, DefaultTableModel modeloTabla) {
        String itemPadre = _extraerItemPresupuesto(filaNodoPadre, columnItem_EnTabla);
        String itemHijo = "";
        int nivel = (itemPadre.length() + 1) / 3;
        int fila_posicionNodoHijoUltimo = filaNodoPadre;
        //Que no pase de la ultima fila
        if (filaNodoPadre + 1 < modeloTabla.getRowCount()) {
//                fila_posicionNodoHijoUltimo++;
            itemHijo = _extraerItemPresupuesto(filaNodoPadre + 1, columnItem_EnTabla);
            while (itemPadre.length() < itemHijo.length()) {
                fila_posicionNodoHijoUltimo++;
                //obtenemos el nivel
                //podriamos haber tomado la columna de niveles del JTable, pero
                //queriamos asegurarnos con los items
                int aux_nivel = ((_extraerItemPresupuesto(fila_posicionNodoHijoUltimo, columnItem_EnTabla).length()) + 1) / 3;
//                    int aux_nivel=(Integer.parseInt(modeloTabla.getValueAt(fila_posicionNodoHijoUltimo, columnItem_EnTabla+8).toString()));
                if (nivel < aux_nivel) {
                    nivel = aux_nivel;
                }
                if (fila_posicionNodoHijoUltimo + 1 >= modeloTabla.getRowCount()) {
                    break;
                }
                itemHijo = _extraerItemPresupuesto(fila_posicionNodoHijoUltimo + 1, columnItem_EnTabla);
            }
            return nivel;
        }
        return nivel;
    }

    public int encontrarElMayorNivel_aPartirDeNodoHijo(int fila_NodoHijo, DefaultTableModel modeloTabla) {
        return -1;
    }

    public boolean itemPadre_contieneNodosHijos_Partidas(int fila_NodoPadre, DefaultTableModel modeloTabla) {
        boolean tieneNodosHijos = true;
        //Controlamos que no pase de los limites del JTable
        if (fila_NodoPadre + 1 < modeloTabla.getRowCount()) {
            String itemPadre = _extraerItemPresupuesto(fila_NodoPadre, columnItem_EnTabla);
            String itemPadre_tipo = modeloTabla.getValueAt(fila_NodoPadre, columnItem_EnTabla + 8).toString();
            String itemHijo = _extraerItemPresupuesto(fila_NodoPadre + 1, columnItem_EnTabla);
            String itemHijo_tipo = modeloTabla.getValueAt(fila_NodoPadre + 1, columnItem_EnTabla + 8).toString();
            while (itemPadre.length() < itemHijo.length()) {
                if (itemHijo_tipo.equals("1")) {
//                    tieneNodosHijos=true;
                    return false;
                }
                fila_NodoPadre++;
                if (fila_NodoPadre + 1 >= modeloTabla.getRowCount()) {
                    break;
                }
                itemHijo = _extraerItemPresupuesto(fila_NodoPadre + 1, columnItem_EnTabla);
                itemHijo_tipo = modeloTabla.getValueAt(fila_NodoPadre + 1, columnItem_EnTabla + 8).toString();
            }
        }
        return tieneNodosHijos;
    }

    public boolean itemPadre_contieneNodos_Padres(int fila, DefaultTableModel modeloTabla) {
        return false;
    }

    public String _extraerItemPresupuesto(int fila, int columna) {
//        JOptionPane.showMessageDialog(null, ""+dlg_presupuesto_prototipo.itemPresupuesto);
        DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
        String item = modeloTabla.getValueAt(fila, columna).toString();
//        System.out.println("_extraerItemPresupuesto-->item:"+item+">>>item.substring(3, item.length()):"+item.substring(3, item.length())+">>>item.length():"+item.length());
        return item.substring(3, item.length());
    }

    public void _escribirItemPresupuesto(Object object, int fila, int columna) {
        DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
        String data = dlg_presupuesto_prototipo.itemPresupuesto + "." + object.toString();
        modeloTabla.setValueAt(data, fila, columna);
        dlg_presupuesto_prototipo.actualizar_item(fila);
    }

    public boolean seEncontroEstaPartida_enTitulo(String idPartida, int filaSeleccionada) {
        DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
        //Obtenemos el tipo de la fila seleccionada
        String item_tipo = modeloTabla.getValueAt(filaSeleccionada, columnItem_EnTabla + 8).toString();
        //Verificamos si este tipo es PARTIDA
        if (item_tipo.equals("0")) {
            //Si es PARTIDA, entonces...
            //Obtenemos los valores de inicio y final de los hijos partidas para recorrerlos y
            //compararlos...
            int filaBusquedaInicial = encontrarPosicionNodoPadre_aPartirDeNodoHijo(filaSeleccionada, modeloTabla);
            int filaBusquedaFinal = encontrarPosicionNodoHijo_ultimo_aPartirDeNodoHijo(filaSeleccionada, modeloTabla);
//            System.out.println("*******----filaBusquedaInicial:"+filaBusquedaInicial+" / "+modeloTabla.getValueAt(filaBusquedaInicial, 1).toString()+" / "+_extraerItemPresupuesto(filaBusquedaInicial, columnItem_EnTabla));
//            System.out.println("*******----filaBusquedaFinal:"+filaBusquedaFinal+" "+modeloTabla.getValueAt(filaBusquedaFinal, 1).toString()+" / "+_extraerItemPresupuesto(filaBusquedaFinal, columnItem_EnTabla));
//            System.out.println("*******----idPartida:"+idPartida);
            String item_idPartida = "";
            //Recorremos las filas y buscamos si se repite esa partida
            for (int i = filaBusquedaInicial + 1; i <= filaBusquedaFinal; i++) {
                item_idPartida = modeloTabla.getValueAt(i, 0).toString();
//                System.out.println("*******----item_idPartida:"+item_idPartida);
//                JOptionPane.showMessageDialog(null, "*114");
                //Comparamos si se repite, o ya se ha ingresado esa partida
                //si es asi, entonces retornamos TRUE, para advertir que se repite
                //y no debe de ingresar esa partida
                if (item_idPartida.equals(idPartida)) {
                    return true;
                }
            }
        } else {//Es NODO PADRE
            //Solo si la fila seleccionada es Nodo Padre - Titulo
            //entonces buscamos dentro de este Titulo la partida si se repite
            int filaBusquedaInicial = filaSeleccionada;
            int filaBusquedaFinal = encontrarPosicionNodoHijo_ultimo_aPartirDeNodoPadre(filaSeleccionada, modeloTabla);
//            System.out.println("*******----filaBusquedaInicial:"+filaBusquedaInicial+" / "+modeloTabla.getValueAt(filaBusquedaInicial, 1).toString()+" / "+_extraerItemPresupuesto(filaBusquedaInicial, columnItem_EnTabla));
//            System.out.println("*******----filaBusquedaFinal:"+filaBusquedaFinal+" "+modeloTabla.getValueAt(filaBusquedaFinal, 1).toString()+" / "+_extraerItemPresupuesto(filaBusquedaFinal, columnItem_EnTabla));
//            System.out.println("*******----idPartida:"+idPartida);
            String item_idPartida = "";
            if (filaBusquedaInicial + 1 < modeloTabla.getRowCount()) {
                //Recorremos las filas y buscamos si se repite esa partida
                for (int i = filaBusquedaInicial + 1; i <= filaBusquedaFinal; i++) {
                    item_idPartida = modeloTabla.getValueAt(i, 0).toString();
                    //                System.out.println("*******----item_idPartida:"+item_idPartida);
                    //                JOptionPane.showMessageDialog(null, "*114");
                    //Comparamos si se repite, o ya se ha ingresado esa partida
                    //si es asi, entonces retornamos TRUE, para advertir que se repite
                    //y no debe de ingresar esa partida
                    if (item_idPartida.equals(idPartida)) {
                        return true;
                    }
                }
            } else {
                //
                return false;
            }
        }
        return false;
    }

    public boolean seEncontroEsteTitulo_enTitulo(String idTitulo, int filaSeleccionada) {
        DefaultTableModel modeloTabla = (DefaultTableModel) tblPresupuesto.getModel();
        //Verificamos a la filaSeleccionada sea diferente de -1
        if (filaSeleccionada != -1) {
            //Obtenemos el tipo de la fila seleccionada
            String item_tipo = modeloTabla.getValueAt(filaSeleccionada, columnItem_EnTabla + 8).toString();
            //Verificamos si este tipo es TITULO
            if (item_tipo.equals("1")) {
                //Si es PARTIDA, entonces...
                //Obtenemos los valores de inicio y final de los hijos partidas para recorrerlos y
                //compararlos...
                int filaBusquedaInicial = encontrarPosicionNodoPadre_aPartirDeNodoHijo(filaSeleccionada, modeloTabla);
                int filaBusquedaFinal = encontrarPosicionNodoHijo_ultimo_aPartirDeNodoHijo(filaSeleccionada, modeloTabla);
                //            System.out.println("*******----filaBusquedaInicial:"+filaBusquedaInicial+" / "+modeloTabla.getValueAt(filaBusquedaInicial, 1).toString()+" / "+_extraerItemPresupuesto(filaBusquedaInicial, columnItem_EnTabla));
                //            System.out.println("*******----filaBusquedaFinal:"+filaBusquedaFinal+" "+modeloTabla.getValueAt(filaBusquedaFinal, 1).toString()+" / "+_extraerItemPresupuesto(filaBusquedaFinal, columnItem_EnTabla));
                //            System.out.println("*******----idTitulo:"+idTitulo);
                String item_idTitulo = "";
                //Recorremos las filas y buscamos si se repite esa partida
                for (int i = filaBusquedaInicial + 1; i <= filaBusquedaFinal; i++) {
                    item_idTitulo = modeloTabla.getValueAt(i, columnItem_EnTabla + 1).toString();
                    //                System.out.println("*******----item_idPartida:"+item_idTitulo);
                    //Comparamos si se repite, o ya se ha ingresado esa partida
                    //si es asi, entonces retornamos TRUE, para advertir que se repite
                    //y no debe de ingresar esa partida
                    if (item_idTitulo.equals(idTitulo)) {
                        return true;
                    }
                }
            }
        }
        return false;
    }

    public String aumentarItem_enUno(String itemString) {
        int valor = Integer.parseInt(itemString.substring(itemString.length() - 2, itemString.length()));
        itemString = itemString.substring(0, itemString.length() - 2);
        valor++;
        if (String.valueOf(valor).length() == 1) {
            itemString = itemString + "0" + valor;
        } else {
            itemString = itemString + "" + valor;
        }
        return itemString;
    }
}
